@pikku/kysely 0.13.24 → 0.13.27

package/src/kysely-workflow-mirror.test.ts

@@ -1,259 +0,0 @@
-import { describe, test, beforeEach, afterEach } from 'node:test'
-import assert from 'node:assert/strict'
-import { CamelCasePlugin, Kysely, SqliteDialect, sql } from 'kysely'
-import { SerializePlugin } from './serialize-plugin.js'
-import Database from 'better-sqlite3'
-
-import type { KyselyPikkuDB } from './kysely-tables.js'
-import { KyselyWorkflowMirror } from './kysely-workflow-mirror.js'
-import { KyselyWorkflowRunService } from './kysely-workflow-run-service.js'
-import { applyPikkuSchemas, workflowSchema } from './schema/index.js'
-
-let db: Kysely<KyselyPikkuDB>
-let mirror: KyselyWorkflowMirror
-let runService: KyselyWorkflowRunService
-
-const RUN_ID = 'run-aaaa'
-const STEP_ID = 'step-bbbb'
-
-beforeEach(async () => {
-  db = new Kysely<KyselyPikkuDB>({
-    dialect: new SqliteDialect({ database: new Database(':memory:') }),
-    plugins: [new CamelCasePlugin(), new SerializePlugin()],
-  })
-  await applyPikkuSchemas(db, [workflowSchema])
-  mirror = new KyselyWorkflowMirror(db)
-  await mirror.init()
-  runService = new KyselyWorkflowRunService(db)
-})
-
-afterEach(async () => {
-  await db.destroy()
-})
-
-async function seedRun(opts?: { input?: any; inline?: boolean }) {
-  await mirror.createRun(
-    RUN_ID,
-    'wf',
-    opts?.input ?? { foo: 1 },
-    opts?.inline ?? false,
-    'hash1',
-    { type: 'do', id: RUN_ID } as any
-  )
-}
-
-async function seedStep(stepId = STEP_ID, stepName = 'step1') {
-  await mirror.insertStepState(RUN_ID, {
-    stepId,
-    stepName,
-    rpcName: 'rpc.fn',
-    data: { x: 1 },
-    status: 'pending',
-    attemptCount: 1,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  } as any)
-}
-
-describe('KyselyWorkflowMirror — runs', () => {
-  test('createRun is visible to KyselyWorkflowRunService.getRun', async () => {
-    await seedRun({ input: { hello: 'world' } })
-    const run = await runService.getRun(RUN_ID)
-    assert.ok(run)
-    assert.equal(run.workflow, 'wf')
-    assert.equal(run.status, 'running')
-    assert.deepEqual(run.input, { hello: 'world' })
-    assert.equal(run.graphHash, 'hash1')
-  })
-
-  test('updateRunStatus reflects in getRun', async () => {
-    await seedRun()
-    await mirror.updateRunStatus(RUN_ID, 'completed', { ok: true })
-    const run = await runService.getRun(RUN_ID)
-    assert.equal(run!.status, 'completed')
-    assert.deepEqual(run!.output, { ok: true })
-  })
-
-  test('listRuns surfaces mirrored runs', async () => {
-    await seedRun()
-    const runs = await runService.listRuns()
-    assert.equal(runs.length, 1)
-    assert.equal(runs[0]!.id, RUN_ID)
-  })
-
-  test('getDistinctWorkflowNames returns mirrored workflow names', async () => {
-    await seedRun()
-    const names = await runService.getDistinctWorkflowNames()
-    assert.deepEqual(names, ['wf'])
-  })
-})
-
-describe('KyselyWorkflowMirror — step lifecycle', () => {
-  beforeEach(async () => {
-    await seedRun()
-  })
-
-  test('insertStepState creates step + initial pending history', async () => {
-    await seedStep()
-    const steps = await runService.getRunSteps(RUN_ID)
-    assert.equal(steps.length, 1)
-    assert.equal(steps[0]!.stepName, 'step1')
-    assert.equal(steps[0]!.status, 'pending')
-
-    const history = await runService.getRunHistory(RUN_ID)
-    assert.equal(history.length, 1)
-    assert.equal(history[0]!.status, 'pending')
-  })
-
-  test('getRunHistory surfaces step provenance (fromStepName)', async () => {
-    // The mirror persists fromStepName and getRunHistory reads it back, so the
-    // run history reconstructs the walked path (entry has none, the next step
-    // records its predecessor).
-    await seedStep(STEP_ID, 'begin')
-    await mirror.insertStepState(RUN_ID, {
-      stepId: `${STEP_ID}-2`,
-      stepName: 'next',
-      rpcName: 'rpc.fn',
-      data: { x: 2 },
-      status: 'pending',
-      attemptCount: 1,
-      fromStepName: 'begin',
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    } as any)
-
-    const history = await runService.getRunHistory(RUN_ID)
-    const from = new Map(history.map((h) => [h.stepName, h.fromStepName]))
-    assert.equal(from.get('begin'), undefined, 'entry step has no predecessor')
-    assert.equal(from.get('next'), 'begin', 'next records its predecessor')
-  })
-
-  test('running → succeeded updates the in-place history row', async () => {
-    await seedStep()
-    await mirror.setStepRunning(STEP_ID)
-    await mirror.setStepResult(STEP_ID, { value: 42 })
-
-    const steps = await runService.getRunSteps(RUN_ID)
-    assert.equal(steps[0]!.status, 'succeeded')
-    assert.deepEqual(steps[0]!.result, { value: 42 })
-
-    const history = await runService.getRunHistory(RUN_ID)
-    assert.equal(history.length, 1, 'updates collapse onto latest history row')
-    assert.equal(history[0]!.status, 'succeeded')
-    assert.deepEqual(history[0]!.result, { value: 42 })
-  })
-
-  test('setStepError stores serialized error', async () => {
-    await seedStep()
-    await mirror.setStepError(STEP_ID, {
-      message: 'boom',
-      stack: 'stack',
-      code: 'EBOOM',
-    })
-
-    const steps = await runService.getRunSteps(RUN_ID)
-    assert.equal(steps[0]!.status, 'failed')
-    assert.equal(steps[0]!.error?.message, 'boom')
-    assert.equal(steps[0]!.error?.code, 'EBOOM')
-  })
-
-  test('createRetryAttempt appends a new history row + clears result/error', async () => {
-    await seedStep()
-    await mirror.setStepError(STEP_ID, { message: 'first try', code: 'X' })
-
-    await mirror.createRetryAttempt(STEP_ID, {
-      stepId: STEP_ID,
-      stepName: 'step1',
-      status: 'pending',
-      attemptCount: 2,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    } as any)
-
-    const steps = await runService.getRunSteps(RUN_ID)
-    assert.equal(steps[0]!.status, 'pending')
-    assert.equal(steps[0]!.error, undefined)
-    assert.equal(steps[0]!.result, undefined)
-
-    const history = await runService.getRunHistory(RUN_ID)
-    // pending (initial — collapsed onto failed) + pending (retry append)
-    assert.equal(history.length, 2)
-    assert.equal(history[0]!.status, 'failed')
-    assert.equal(history[1]!.status, 'pending')
-  })
-
-  test('setStepChildRunId persists', async () => {
-    await seedStep()
-    await mirror.setStepChildRunId(STEP_ID, 'child-run-1')
-    const steps = await runService.getRunSteps(RUN_ID)
-    assert.equal((steps[0] as any).childRunId, 'child-run-1')
-  })
-
-  test('setBranchTaken persists the branch key', async () => {
-    await seedStep()
-    await mirror.setBranchTaken(STEP_ID, 'left')
-    const row = await db
-      .selectFrom('workflowStep')
-      .select('branchTaken')
-      .where('workflowStepId', '=', STEP_ID)
-      .executeTakeFirst()
-    assert.equal(row?.branchTaken, 'left')
-  })
-})
-
-describe('KyselyWorkflowMirror — run state', () => {
-  beforeEach(async () => {
-    await seedRun()
-  })
-
-  test('updateRunState merges values', async () => {
-    await mirror.updateRunState(RUN_ID, 'counter', 1)
-    await mirror.updateRunState(RUN_ID, 'flag', true)
-    const row = await db
-      .selectFrom('workflowRuns')
-      .select('state')
-      .where('workflowRunId', '=', RUN_ID)
-      .executeTakeFirst()
-    const state =
-      typeof row?.state === 'string' ? JSON.parse(row.state) : row?.state
-    assert.deepEqual(state, { counter: 1, flag: true })
-  })
-})
-
-describe('KyselyWorkflowMirror — workflow versions', () => {
-  test('upsertWorkflowVersion is idempotent on (name, hash)', async () => {
-    await mirror.upsertWorkflowVersion('wf', 'h1', { v: 1 }, 'graph')
-    await mirror.upsertWorkflowVersion('wf', 'h1', { v: 2 }, 'graph')
-    const v = await runService.getWorkflowVersion('wf', 'h1')
-    assert.deepEqual(v?.graph, { v: 1 }, 'first write wins (doNothing)')
-  })
-
-  test('updateWorkflowVersionStatus mutates status', async () => {
-    await mirror.upsertWorkflowVersion('wf', 'h1', {}, 'graph', 'active')
-    await mirror.updateWorkflowVersionStatus('wf', 'h1', 'archived')
-    const row = await db
-      .selectFrom('workflowVersions')
-      .select('status')
-      .where('workflowName', '=', 'wf')
-      .where('graphHash', '=', 'h1')
-      .executeTakeFirst()
-    assert.equal(row?.status, 'archived')
-  })
-})
-
-describe('KyselyWorkflowMirror — init', () => {
-  test('init is idempotent', async () => {
-    await mirror.init()
-    await mirror.init()
-    // No-op on second call; just shouldn't throw.
-  })
-
-  test('cohabits with KyselyWorkflowService, which declares the same tables', async () => {
-    // Both services own the workflow schema, so both call init() against the
-    // same database. The second one to run must find the tables and stop, not
-    // try to create them again. Importing the other service needs the
-    // singleton-services bootstrap, so a fresh instance stands in for it.
-    const second = new KyselyWorkflowMirror(db)
-    await assert.doesNotReject(second.init())
-  })
-})

package/src/kysely-workflow-mirror.ts

@@ -1,374 +0,0 @@
-import type { SerializedError } from '@pikku/core/errors'
-import type {
-  StepState,
-  WorkflowRunMirror,
-  WorkflowRunWire,
-  WorkflowStatus,
-  WorkflowPlannedStep,
-  WorkflowVersionStatus,
-} from '@pikku/core/workflow'
-import type { Kysely } from 'kysely'
-import type { KyselyPikkuDB } from './kysely-tables.js'
-import { requirePikkuSchema } from './schema/index.js'
-import { workflowSchema } from './schema/workflow.schema.js'
-
-/**
- * Kysely-backed `WorkflowRunMirror`.
- *
- * Forwards executor writes to the same `workflow_runs` / `workflow_step` /
- * `workflow_step_history` / `workflow_versions` tables that
- * `KyselyWorkflowService` uses, so a `KyselyWorkflowRunService` reading
- * those tables will see runs driven by any executor (Cloudflare Durable
- * Object, Redis, MongoDB, in-memory) — not just kysely-driven runs.
- *
- * Errors thrown here are caught by the executor's `safeMirror` wrapper
- * and logged, so a mirror outage cannot break a running workflow.
- */
-export class KyselyWorkflowMirror implements WorkflowRunMirror {
-  private initialized = false
-
-  constructor(protected db: Kysely<KyselyPikkuDB>) {}
-
-  /**
-   * Create the underlying tables if none of them exist yet.
-   *
-   * Safe to call from either the mirror or `KyselyWorkflowService.init()` —
-   * both apply the same `workflowSchema`, and `requirePikkuSchema` is a no-op
-   * once the tables are there. A database holding only *part* of the schema
-   * throws rather than filling in the rest: something else owns those tables,
-   * and boot is not where that gets reconciled.
-   */
-  public async init(): Promise<void> {
-    if (this.initialized) return
-    await requirePikkuSchema(this.db, workflowSchema)
-    this.initialized = true
-  }
-
-  async createRun(
-    runId: string,
-    workflowName: string,
-    input: any,
-    inline: boolean,
-    graphHash: string,
-    wire: WorkflowRunWire,
-    options?: {
-      deterministic?: boolean
-      plannedSteps?: WorkflowPlannedStep[]
-    }
-  ): Promise<void> {
-    await this.db
-      .insertInto('workflowRuns')
-      .values({
-        workflowRunId: runId,
-        workflow: workflowName,
-        status: 'running',
-        input: JSON.stringify(input),
-        inline,
-        graphHash: graphHash ?? null,
-        deterministic: options?.deterministic ?? false,
-        plannedSteps: options?.plannedSteps
-          ? JSON.stringify(options.plannedSteps)
-          : null,
-        wire: wire ? JSON.stringify(wire) : null,
-      })
-      .execute()
-  }
-
-  async updateRunStatus(
-    id: string,
-    status: WorkflowStatus,
-    output?: any,
-    error?: SerializedError
-  ): Promise<void> {
-    await this.db
-      .updateTable('workflowRuns')
-      .set({
-        status,
-        output: output !== undefined ? JSON.stringify(output) : null,
-        error: error !== undefined ? JSON.stringify(error) : null,
-        updatedAt: new Date(),
-      })
-      .where('workflowRunId', '=', id)
-      .execute()
-  }
-
-  async insertStepState(
-    runId: string,
-    step: StepState & {
-      stepName: string
-      rpcName: string | null
-      data: any
-    }
-  ): Promise<void> {
-    const now = step.createdAt ?? new Date()
-
-    await this.db
-      .insertInto('workflowStep')
-      .values({
-        workflowStepId: step.stepId,
-        workflowRunId: runId,
-        stepName: step.stepName,
-        rpcName: step.rpcName,
-        data: step.data != null ? JSON.stringify(step.data) : null,
-        status: step.status,
-        retries: step.retries ?? null,
-        retryDelay: step.retryDelay?.toString() ?? null,
-        fromStepName: step.fromStepName ?? null,
-        currentAttempt: 1,
-        createdAt: now,
-        updatedAt: now,
-      })
-      .execute()
-
-    await this.insertHistoryRecord(step.stepId, step.status, 1)
-  }
-
-  async setStepRunning(stepId: string): Promise<void> {
-    await this.updateStepStatus(stepId, 'running')
-    await this.appendOrUpdateLatestHistory(stepId, 'running')
-  }
-
-  async setStepScheduled(stepId: string): Promise<void> {
-    await this.updateStepStatus(stepId, 'scheduled')
-  }
-
-  async setStepResult(stepId: string, result: any): Promise<void> {
-    const resultJson = JSON.stringify(result)
-    await this.db
-      .updateTable('workflowStep')
-      .set({
-        status: 'succeeded',
-        result: resultJson,
-        error: null,
-        updatedAt: new Date(),
-      })
-      .where('workflowStepId', '=', stepId)
-      .execute()
-    await this.appendOrUpdateLatestHistory(stepId, 'succeeded', resultJson)
-  }
-
-  async setStepChildRunId(stepId: string, childRunId: string): Promise<void> {
-    await this.db
-      .updateTable('workflowStep')
-      .set({ childRunId, updatedAt: new Date() })
-      .where('workflowStepId', '=', stepId)
-      .execute()
-  }
-
-  async setStepError(stepId: string, error: SerializedError): Promise<void> {
-    const errorJson = JSON.stringify(error)
-    await this.db
-      .updateTable('workflowStep')
-      .set({
-        status: 'failed',
-        error: errorJson,
-        result: null,
-        updatedAt: new Date(),
-      })
-      .where('workflowStepId', '=', stepId)
-      .execute()
-    await this.appendOrUpdateLatestHistory(
-      stepId,
-      'failed',
-      undefined,
-      errorJson
-    )
-  }
-
-  async createRetryAttempt(
-    failedStepId: string,
-    newStep: StepState & { stepName: string }
-  ): Promise<void> {
-    const previous = await this.db
-      .selectFrom('workflowStep')
-      .select('currentAttempt')
-      .where('workflowStepId', '=', failedStepId)
-      .executeTakeFirst()
-    const attempt = (previous?.currentAttempt ?? 0) + 1
-
-    await this.db
-      .updateTable('workflowStep')
-      .set({
-        status: newStep.status,
-        result: null,
-        error: null,
-        currentAttempt: attempt,
-        updatedAt: new Date(),
-      })
-      .where('workflowStepId', '=', failedStepId)
-      .execute()
-    await this.insertHistoryRecord(failedStepId, newStep.status, attempt)
-  }
-
-  async setBranchTaken(stepId: string, branchKey: string): Promise<void> {
-    await this.db
-      .updateTable('workflowStep')
-      .set({ branchTaken: branchKey, updatedAt: new Date() })
-      .where('workflowStepId', '=', stepId)
-      .execute()
-  }
-
-  async updateRunState(
-    runId: string,
-    name: string,
-    value: unknown
-  ): Promise<void> {
-    const row = await this.db
-      .selectFrom('workflowRuns')
-      .select('state')
-      .where('workflowRunId', '=', runId)
-      .executeTakeFirst()
-
-    const state: Record<string, unknown> =
-      row?.state != null
-        ? typeof row.state === 'string'
-          ? JSON.parse(row.state)
-          : row.state
-        : {}
-    state[name] = value
-
-    await this.db
-      .updateTable('workflowRuns')
-      .set({ state: JSON.stringify(state), updatedAt: new Date() })
-      .where('workflowRunId', '=', runId)
-      .execute()
-  }
-
-  async upsertWorkflowVersion(
-    name: string,
-    graphHash: string,
-    graph: any,
-    source: string,
-    status: WorkflowVersionStatus = 'active'
-  ): Promise<void> {
-    await this.db
-      .insertInto('workflowVersions')
-      .values({
-        workflowName: name,
-        graphHash,
-        graph: JSON.stringify(graph),
-        source,
-        status,
-      })
-      .onConflict((oc) => oc.columns(['workflowName', 'graphHash']).doNothing())
-      .execute()
-  }
-
-  async updateWorkflowVersionStatus(
-    name: string,
-    graphHash: string,
-    status: WorkflowVersionStatus
-  ): Promise<void> {
-    await this.db
-      .updateTable('workflowVersions')
-      .set({ status })
-      .where('workflowName', '=', name)
-      .where('graphHash', '=', graphHash)
-      .execute()
-  }
-
-  // ─── internals ────────────────────────────────────────────────────
-
-  private async updateStepStatus(
-    stepId: string,
-    status: StepState['status']
-  ): Promise<void> {
-    await this.db
-      .updateTable('workflowStep')
-      .set({ status, updatedAt: new Date() })
-      .where('workflowStepId', '=', stepId)
-      .execute()
-  }
-
-  private async insertHistoryRecord(
-    stepId: string,
-    status: string,
-    attempt: number,
-    resultJson?: string | null,
-    errorJson?: string | null
-  ): Promise<void> {
-    const now = new Date()
-    const values: Record<string, any> = {
-      historyId: crypto.randomUUID(),
-      workflowStepId: stepId,
-      status,
-      attempt,
-      result: resultJson ?? null,
-      error: errorJson ?? null,
-      createdAt: now,
-    }
-    const tsField = timestampFieldFor(status)
-    if (tsField) values[tsField] = now
-
-    await this.db
-      .insertInto('workflowStepHistory')
-      .values(values as any)
-      .execute()
-  }
-
-  /**
-   * The executor pattern is: `insertStepState` writes a 'pending' history
-   * row, then later transitions UPDATE that latest row in place rather
-   * than appending a new one — except for retry attempts which append.
-   *
-   * We mirror the same shape so `KyselyWorkflowRunService.getRunHistory`
-   * returns the same sequence the executor would have produced.
-   */
-  private async appendOrUpdateLatestHistory(
-    stepId: string,
-    status: string,
-    resultJson?: string,
-    errorJson?: string
-  ): Promise<void> {
-    const update: Record<string, any> = { status }
-    if (resultJson !== undefined) update.result = resultJson
-    if (errorJson !== undefined) update.error = errorJson
-    const tsField = timestampFieldFor(status)
-    if (tsField) update[tsField] = new Date()
-
-    const result = await this.db
-      .updateTable('workflowStepHistory')
-      .set(update)
-      .where('workflowStepId', '=', stepId)
-      // Correlate through the step row rather than sorting this table by
-      // createdAt: two attempts can land in the same millisecond, and the
-      // step row already knows which attempt is current.
-      .where('attempt', '=', (eb) =>
-        eb
-          .selectFrom('workflowStep')
-          .select('currentAttempt')
-          .where('workflowStepId', '=', stepId)
-      )
-      .executeTakeFirst()
-
-    if (Number(result?.numUpdatedRows ?? 0n) === 0) {
-      const step = await this.db
-        .selectFrom('workflowStep')
-        .select('currentAttempt')
-        .where('workflowStepId', '=', stepId)
-        .executeTakeFirst()
-      await this.insertHistoryRecord(
-        stepId,
-        status,
-        step?.currentAttempt ?? 1,
-        resultJson,
-        errorJson
-      )
-    }
-  }
-}
-
-function timestampFieldFor(status: string): string | null {
-  switch (status) {
-    case 'running':
-      return 'runningAt'
-    case 'scheduled':
-      return 'scheduledAt'
-    case 'succeeded':
-      return 'succeededAt'
-    case 'failed':
-      return 'failedAt'
-    default:
-      return null
-  }
-}