@sixb/core 0.1.1 → 0.1.3

package/src/testing/ontology-storage-contract.ts

@@ -7,6 +7,7 @@ import type {
   MaterializationPlanFinalization,
   MaterializationPlanHeader,
   MaterializationSession,
+  OntologyOutboxFailure,
   OntologySourceRecord,
 } from "../storage/ontology"
 import type { ProjectionRunStorage } from "../storage/projection-runs"
@@ -15,8 +16,10 @@ import {
   commitExactObject,
   contractEditHeader,
   contractEditResult,
+  ensureContractExecution,
   type OntologyContractStorage,
 } from "./ontology-contract-fixture"
+import { startTestProjectionRun } from "./projection-execution"
 
 export interface OntologyStorageContractStorage extends OntologyContractStorage {
   readonly projectionRuns: ProjectionRunStorage
@@ -69,6 +72,16 @@ interface ReadyCandidate {
   readonly execution: ProjectionExecution
   readonly materializationId: string
   readonly source: { readonly projectionId: string }
+  readonly executionId: string
+}
+
+function ontologyOutboxFailure(message: string): OntologyOutboxFailure {
+  return {
+    code: "event.delivery_failed",
+    message,
+    retryable: true,
+    at: "2026-01-03T02:00:00.000Z",
+  }
 }
 
 /**
@@ -120,6 +133,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
         ;(divergent.commit as { requestHash: string }).requestHash = "different-hash"
         await expect(
           storage.transaction(async (tx) => {
+            await ensureContractExecution(tx, divergent)
             await tx.ontology.materializations.begin(divergent)
           })
         ).rejects.toMatchObject({ kind: "idempotency" })
@@ -134,6 +148,30 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
       })
     })
 
+    test("rejects an ontology commit whose execution does not exist", async () => {
+      await withStorage(async (storage) => {
+        const header = contractEditHeader("missing-execution")
+        await expect(
+          storage.transaction(async (tx) => {
+            const session = await tx.ontology.materializations.begin(header)
+            await tx.ontology.materializations.finalize({
+              session,
+              finalization: {
+                sourceActivations: [],
+                result: contractEditResult(header.commit.id),
+              },
+            })
+          })
+        ).rejects.toThrow()
+        await expect(
+          storage.ontology.commits.getById({
+            projectId: header.commit.projectId,
+            id: header.commit.id,
+          })
+        ).resolves.toBeNull()
+      })
+    })
+
     test("rejects unfinished sessions and rolls back their authoritative writes", async () => {
       await withStorage(async (storage) => {
         const header = contractEditHeader("session-contract")
@@ -170,9 +208,9 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
         let leakedSession: MaterializationSession | undefined
         await expect(
           storage.transaction(async (tx) => {
-            leakedSession = await tx.ontology.materializations.begin(
-              contractEditHeader("leaked-session")
-            )
+            const leakedHeader = contractEditHeader("leaked-session")
+            await ensureContractExecution(tx, leakedHeader)
+            leakedSession = await tx.ontology.materializations.begin(leakedHeader)
           })
         ).rejects.toThrow("unfinished materialization session")
         if (!leakedSession) throw new Error("Expected an unfinished session handle")
@@ -194,7 +232,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
     test("stages insert-only source rows, seals counts, and fences stale execution tokens", async () => {
       await withStorage(async (storage) => {
         const identity = replacementIdentity("01")
-        const claimed = await storage.projectionRuns.startOrReclaim({
+        const claimed = await startTestProjectionRun(storage, {
           id: "staging-run",
           projectId: "contract-project",
           identity,
@@ -583,7 +621,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           ids: [reclaimed[0].envelope.id],
           leaseId: "lease-two",
           availableAt: "2026-01-04T00:00:00.000Z",
-          error: "broker unavailable",
+          failure: ontologyOutboxFailure("broker unavailable"),
         })
         const retried = await storage.ontology.outbox.claim({
           projectId: "contract-project",
@@ -592,14 +630,34 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           leaseId: "lease-three",
           leaseExpiresAt: "2026-01-04T01:00:00.000Z",
         })
-        expect(retried[0]).toMatchObject({ attempts: 3, lastError: "broker unavailable" })
+        expect(retried[0]).toMatchObject({
+          attempts: 3,
+          lastFailure: ontologyOutboxFailure("broker unavailable"),
+        })
+        await storage.ontology.outbox.reschedule({
+          projectId: "contract-project",
+          ids: [retried[0].envelope.id],
+          leaseId: "lease-three",
+          availableAt: "2026-01-04T00:15:00.000Z",
+        })
+        const lifecycleRescheduled = await storage.ontology.outbox.claim({
+          projectId: "contract-project",
+          now: "2026-01-04T00:15:00.000Z",
+          limit: 1,
+          leaseId: "lease-four",
+          leaseExpiresAt: "2026-01-04T01:15:00.000Z",
+        })
+        expect(lifecycleRescheduled[0]).toMatchObject({
+          attempts: 4,
+          lastFailure: ontologyOutboxFailure("broker unavailable"),
+        })
         expect(
           await storage.ontology.outbox.summarize({ projectId: "contract-project" })
-        ).toMatchObject({ pendingCount: 2, retryingCount: 2, maxAttempts: 3 })
+        ).toMatchObject({ pendingCount: 2, retryingCount: 2, maxAttempts: 4 })
         await storage.ontology.outbox.markPublished({
           projectId: "contract-project",
-          ids: [retried[0].envelope.id],
-          leaseId: "lease-three",
+          ids: [lifecycleRescheduled[0].envelope.id],
+          leaseId: "lease-four",
           publishedAt: "2026-01-04T00:30:00.000Z",
         })
         expect(
@@ -672,7 +730,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
           projectionRevision: "telemetry-contract-revision",
           ownershipHash: "telemetry-contract-ownership",
         }
-        const run = await storage.projectionRuns.startOrReclaim({
+        const run = await startTestProjectionRun(storage, {
           id: "telemetry-run",
           projectId: "contract-project",
           identity,
@@ -684,7 +742,7 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
             if (!tx.projectionRuns) {
               throw new Error("Contract transaction omitted required storage facades.")
             }
-            const header = telemetryHeader(identity, run.run.id)
+            const header = telemetryHeader(identity, run.run.id, run.run.executionId)
             const session = await tx.ontology.materializations.begin(header)
             await tx.ontology.materializations.finalize({
               session,
@@ -754,7 +812,7 @@ async function createReadyEmptyCandidate(
   versionId: string
 ): Promise<ReadyCandidate> {
   const identity = replacementIdentity(versionId)
-  const run = await storage.projectionRuns.startOrReclaim({
+  const run = await startTestProjectionRun(storage, {
     id: runId,
     projectId: "contract-project",
     identity,
@@ -784,7 +842,7 @@ async function createReadyEmptyCandidate(
     assertionCount: 0,
     readyAt: new Date(Date.parse(identity.datasetVersion.createdAt) + 1_000).toISOString(),
   })
-  return { identity, execution, materializationId, source }
+  return { identity, execution, materializationId, source, executionId: run.run.executionId }
 }
 
 async function activateEmptyCandidate(
@@ -805,6 +863,7 @@ async function activateEmptyCandidate(
       id: commitId,
       idempotencyKey: `projection:${commitId}`,
       requestHash: `hash:${commitId}`,
+      executionId: candidate.executionId,
       origin: {
         kind: "projection",
         projectionId: candidate.source.projectionId,
@@ -878,7 +937,8 @@ async function activateEmptyCandidate(
 
 function telemetryHeader(
   identity: ProjectionMaterializationIdentity,
-  projectionRunId: string
+  projectionRunId: string,
+  executionId: string
 ): MaterializationPlanHeader {
   if (identity.protocol !== "telemetry") throw new Error("Expected telemetry identity")
   return {
@@ -887,6 +947,7 @@ function telemetryHeader(
       id: "telemetry-commit",
       idempotencyKey: "telemetry:telemetry-run:0",
       requestHash: "hash:telemetry-run:0",
+      executionId,
       origin: {
         kind: "telemetry",
         source: {

package/src/testing/pipeline-execution.ts

@@ -0,0 +1,64 @@
+import type { TrustedPrimitiveRef } from "../execution"
+import type { PipelineRunRecord, QueuePipelineRunInput, Storage } from "../storage"
+import type { ExecutionStorage } from "../storage/executions"
+
+/** Create the durable execution required by a Pipeline-run storage fixture. */
+export async function createTestPipelineExecution(
+  executions: ExecutionStorage,
+  input: {
+    readonly projectId: string
+    readonly pipelineId: string
+    readonly runId: string
+    readonly executionId?: string
+  }
+): Promise<string> {
+  const executionId = input.executionId ?? `test_pipeline_execution:${input.runId}`
+  const existing = await executions.getById({ projectId: input.projectId, id: executionId })
+  if (existing) return executionId
+
+  const primitive: TrustedPrimitiveRef = {
+    kind: "pipeline",
+    id: input.pipelineId,
+    runId: input.runId,
+  }
+  await executions.create({
+    id: executionId,
+    projectId: input.projectId,
+    executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
+    source: { type: "event", eventId: `test_event:${input.runId}` },
+    correlationId: `test_correlation:${input.runId}`,
+    authorizationRef: { type: "trustedPrimitive", primitive },
+  })
+  return executionId
+}
+
+/** Queue a Pipeline run with the valid durable execution fixture required by every provider. */
+export async function queueTestPipelineRun(
+  storage: Pick<Storage, "pipelineRuns" | "executions">,
+  input: Omit<QueuePipelineRunInput, "executionId">
+): Promise<PipelineRunRecord> {
+  if (!storage.pipelineRuns)
+    throw new Error("Pipeline run storage is not configured for this test.")
+  const executionId = await createTestPipelineExecution(storage.executions, {
+    projectId: input.projectId,
+    pipelineId: input.pipelineId,
+    runId: input.id,
+  })
+  return storage.pipelineRuns.queue({ ...input, executionId })
+}
+
+/** Start a Pipeline run after creating its durable execution and queued state. */
+export async function startTestPipelineRun(
+  storage: Pick<Storage, "pipelineRuns" | "executions">,
+  input: Omit<QueuePipelineRunInput, "executionId" | "queuedAt"> & {
+    readonly startedAt?: Date
+  }
+): Promise<PipelineRunRecord> {
+  const { startedAt, ...queuedRun } = input
+  await queueTestPipelineRun(storage, { ...queuedRun, queuedAt: startedAt })
+  return storage.pipelineRuns!.start({
+    id: input.id,
+    projectId: input.projectId,
+    startedAt,
+  })
+}

package/src/testing/projection-execution.ts

@@ -0,0 +1,98 @@
+import type { TrustedPrimitiveRef } from "../execution"
+import type {
+  ProjectionRunClaim,
+  ProjectionRunRecord,
+  QueueProjectionRunInput,
+  StartOrReclaimProjectionRunInput,
+  Storage,
+} from "../storage"
+import type { ExecutionStorage } from "../storage/executions"
+
+type ProjectionRunQueueFixtureInput = QueueProjectionRunInput extends infer TInput
+  ? TInput extends QueueProjectionRunInput
+    ? Omit<TInput, "executionId">
+    : never
+  : never
+
+/** Create the durable execution required by a Projection-run storage fixture. */
+export async function createTestProjectionExecution(
+  executions: ExecutionStorage,
+  input: {
+    readonly projectId: string
+    readonly projectionId: string
+    readonly runId: string
+    readonly datasetId: string
+    readonly datasetVersionId: string
+    readonly executionId?: string
+  }
+): Promise<string> {
+  const executionId = input.executionId ?? `test_projection_execution:${input.runId}`
+  const existing = await executions.getById({ projectId: input.projectId, id: executionId })
+  if (existing) return executionId
+
+  const primitive: TrustedPrimitiveRef = {
+    kind: "projection",
+    id: input.projectionId,
+    runId: input.runId,
+  }
+  await executions.create({
+    id: executionId,
+    projectId: input.projectId,
+    executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
+    source: {
+      type: "datasetVersion",
+      datasetId: input.datasetId,
+      versionId: input.datasetVersionId,
+    },
+    correlationId: `test_correlation:${input.runId}`,
+    authorizationRef: { type: "trustedPrimitive", primitive },
+  })
+  return executionId
+}
+
+/** Queue a Projection run with the valid durable execution fixture required by every provider. */
+export async function queueTestProjectionRun(
+  storage: Pick<Storage, "projectionRuns" | "executions">,
+  input: ProjectionRunQueueFixtureInput
+): Promise<ProjectionRunRecord> {
+  if (!storage.projectionRuns)
+    throw new Error("Projection run storage is not configured for this test.")
+  const executionId = await createTestProjectionExecution(storage.executions, {
+    projectId: input.projectId,
+    projectionId: input.identity.projectionId,
+    runId: input.id,
+    datasetId: input.identity.datasetVersion.datasetId,
+    datasetVersionId: input.identity.datasetVersion.versionId,
+  })
+  return storage.projectionRuns.queue({ ...input, executionId })
+}
+
+/** Start a Projection run after creating its durable execution and queued state. */
+export async function startTestProjectionRun(
+  storage: Pick<Storage, "projectionRuns" | "executions">,
+  input: StartOrReclaimProjectionRunInput
+): Promise<ProjectionRunClaim> {
+  const projectionRuns = storage.projectionRuns
+  if (!projectionRuns) throw new Error("Projection run storage is not configured for this test.")
+  const { startedAt, ...queuedRun } = input
+  await queueTestProjectionRun(storage, { ...queuedRun, queuedAt: startedAt })
+  return projectionRuns.startOrReclaim(input)
+}
+
+/** Claim a queued fixture, or rotate its attempt when the same durable run is reclaimed. */
+export async function claimTestProjectionRun(
+  storage: Pick<Storage, "projectionRuns" | "executions">,
+  input: StartOrReclaimProjectionRunInput
+): Promise<ProjectionRunClaim> {
+  if (!storage.projectionRuns)
+    throw new Error("Projection run storage is not configured for this test.")
+  const existing = await storage.projectionRuns.getById({
+    projectId: input.projectId,
+    id: input.id,
+  })
+  if (!existing) {
+    const { startedAt, ...queuedRun } = input
+    await queueTestProjectionRun(storage, { ...queuedRun, queuedAt: startedAt })
+  }
+  return storage.projectionRuns.startOrReclaim(input)
+}