@boboddy/sdk 0.0.7-alpha → 0.0.9-alpha

package/dist/packages/core/src/pipeline-executions/step-execution/application/complete-claimed-step-execution.d.ts

@@ -0,0 +1,35 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { InMemoryDomainEventDispatcher } from "@boboddy/core/lib/domain-events/in-memory-domain-event-dispatcher";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { LinearPipelineExecutionRepo } from "@boboddy/core/pipeline-executions/pipeline-execution/application/linear-pipeline-execution-repo";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import { type CompleteClaimedStepExecutionInput, type GetStepExecutionInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionRepo } from "./step-execution-repo";
+export declare const completeClaimedStepExecution: (stepExecutionIdInput: GetStepExecutionInput, input: CompleteClaimedStepExecutionInput, { stepExecutionRepo, stepDefinitionRepo, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    timeProvider: TimeProvider;
+    domainEventDispatcher?: InMemoryDomainEventDispatcher;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionContract>;
+export declare const failTimedOutStepExecution: (stepExecutionIdInput: GetStepExecutionInput, { stepExecutionRepo, stepDefinitionRepo, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    timeProvider: TimeProvider;
+    domainEventDispatcher?: InMemoryDomainEventDispatcher;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionContract>;
+export declare const failAbandonedStepExecution: (stepExecutionIdInput: GetStepExecutionInput, { stepExecutionRepo, stepDefinitionRepo, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    timeProvider: TimeProvider;
+    domainEventDispatcher?: InMemoryDomainEventDispatcher;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionContract>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/create-step-execution.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type CreateStepExecutionInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionRepo } from "./step-execution-repo";
+export declare const createStepExecution: (input: CreateStepExecutionInput, { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionContract>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/extract-step-execution-signals.d.ts

@@ -0,0 +1,13 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { InMemoryDomainEventDispatcher } from "@boboddy/core/lib/domain-events/in-memory-domain-event-dispatcher";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import { type GetStepExecutionResultInput, type StepSignalContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionRepo } from "./step-execution-repo";
+export declare const extractStepExecutionSignals: (input: GetStepExecutionResultInput, { stepDefinitionRepo, stepExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
+    stepDefinitionRepo: StepDefinitionRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    domainEventDispatcher?: InMemoryDomainEventDispatcher;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepSignalContract[]>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/get-step-execution-worker-context.d.ts

@@ -0,0 +1,13 @@
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { ProjectRepo } from "@boboddy/core/projects/project/application/project-repo";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import type { ProjectContextEntryRepo } from "@boboddy/core/projects/project-context/application/project-context-entry-repo";
+import { type GetStepExecutionInput, type GetStepExecutionWorkerContextInput, type StepExecutionWorkerContextContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionRepo } from "./step-execution-repo";
+export declare const getStepExecutionWorkerContext: (stepExecutionIdInput: GetStepExecutionInput, input: GetStepExecutionWorkerContextInput, { projectRepo, stepExecutionRepo, stepDefinitionRepo, projectContextEntryRepo, timeProvider, }: {
+    projectRepo: ProjectRepo;
+    stepExecutionRepo: StepExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    projectContextEntryRepo: ProjectContextEntryRepo;
+    timeProvider: TimeProvider;
+}) => Promise<StepExecutionWorkerContextContract>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/get-step-execution.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { type GetStepExecutionInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionRepo } from "./step-execution-repo";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+export declare const getStepExecution: (input: GetStepExecutionInput, { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionContract>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/heartbeat-step-execution-claim.d.ts

@@ -0,0 +1,17 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { InMemoryDomainEventDispatcher } from "@boboddy/core/lib/domain-events/in-memory-domain-event-dispatcher";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { LinearPipelineExecutionRepo } from "@boboddy/core/pipeline-executions/pipeline-execution/application/linear-pipeline-execution-repo";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import { type GetStepExecutionInput, type StepExecutionClaimCommandInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionRepo } from "./step-execution-repo";
+export declare const heartbeatStepExecutionClaim: (stepExecutionIdInput: GetStepExecutionInput, input: StepExecutionClaimCommandInput, { stepExecutionRepo, stepDefinitionRepo, linearPipelineDefinitionRepo, linearPipelineExecutionRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    stepDefinitionRepo: StepDefinitionRepo;
+    linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo;
+    linearPipelineExecutionRepo: LinearPipelineExecutionRepo;
+    timeProvider: TimeProvider;
+    domainEventDispatcher?: InMemoryDomainEventDispatcher;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionContract>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/list-step-executions-by-project.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { type ListStepExecutionsByProjectIdInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionRepo } from "./step-execution-repo";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+export declare const listStepExecutionsByProjectId: (input: ListStepExecutionsByProjectIdInput, { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionContract[]>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/load-status-adjusted-step-executions.d.ts

@@ -0,0 +1,31 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { StepExecutionEntity } from "../domain/step-execution-entity";
+import type { StepExecutionRepo } from "./step-execution-repo";
+export declare const loadStatusAdjustedStepExecution: (stepExecutionId: UuidV7, { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionEntity | null>;
+export declare const loadStatusAdjustedStepExecutionsByIds: (stepExecutionIds: UuidV7[], { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<(StepExecutionEntity | null)[]>;
+export declare const loadStatusAdjustedStepExecutionByResultId: (stepExecutionResultId: UuidV7, { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionEntity | null>;
+export declare const listStatusAdjustedStepExecutionsByProjectId: (projectId: UuidV7, { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionEntity[]>;
+export declare const loadStatusAdjustedClaimableStepExecutionsByProjectId: (projectId: UuidV7, limit: number, now: Date, { stepExecutionRepo, timeProvider, dbExecutor, workItemId, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+    workItemId?: string | undefined;
+}) => Promise<StepExecutionEntity[]>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/mark-step-execution-running.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import { type GetStepExecutionInput, type StepExecutionContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionRepo } from "./step-execution-repo";
+export declare const markStepExecutionRunning: (input: GetStepExecutionInput, { stepExecutionRepo, timeProvider, dbExecutor, }: {
+    stepExecutionRepo: StepExecutionRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<StepExecutionContract>;

package/dist/packages/core/src/pipeline-executions/step-execution/application/step-execution-claim-helpers.d.ts

@@ -0,0 +1,13 @@
+import type { AnyJsonValue } from "@boboddy/core/common/contracts/json";
+import type { StepExecutionEntity } from "../domain/step-execution-entity";
+export declare const buildLeaseExpiresAt: (now: Date, leaseDurationSeconds: number) => Date;
+export declare const buildExecutionDeadlineAt: (stepExecution: StepExecutionEntity, now: Date) => Date | null;
+export declare const buildTimedOutStepExecutionResult: (stepExecution: StepExecutionEntity, now: Date) => {
+    resultJson: AnyJsonValue;
+    errorJson: AnyJsonValue;
+};
+export declare const buildAbandonedStepExecutionResult: (stepExecution: StepExecutionEntity, now: Date) => {
+    resultJson: AnyJsonValue;
+    errorJson: AnyJsonValue;
+};
+export declare const assertClaimOwnership: (stepExecution: StepExecutionEntity, claimToken: string, now: Date) => void;

package/dist/packages/core/src/pipeline-executions/step-execution/application/step-execution-contract-mapper.d.ts

@@ -0,0 +1,7 @@
+import type { StepExecutionContract, StepExecutionResultContract, StepSignalContract } from "../contracts/step-execution-contracts";
+import type { StepExecutionEntity } from "../domain/step-execution-entity";
+import type { StepExecutionResultEntity } from "../entities/step-execution-result-entity";
+import type { StepSignalEntity } from "../entities/step-signal-entity";
+export declare const stepSignalEntityToContract: (signal: StepSignalEntity) => StepSignalContract;
+export declare const stepExecutionResultEntityToContract: (result: StepExecutionResultEntity) => StepExecutionResultContract;
+export declare const stepExecutionEntityToContract: (stepExecution: StepExecutionEntity) => StepExecutionContract;

package/dist/packages/core/src/pipeline-executions/step-execution/application/step-execution-repo.d.ts

@@ -0,0 +1,29 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { StepExecutionEntity } from "../domain/step-execution-entity";
+import type { StepExecutionResultEntity } from "../entities/step-execution-result-entity";
+import type { StepSignalEntity } from "../entities/step-signal-entity";
+export type StepExecutionRepo = {
+    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
+    loadMany(ids: UuidV7[], dbExecutor?: DbExecutor): Promise<(StepExecutionEntity | null)[]>;
+    loadByResultId(stepExecutionResultId: UuidV7, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
+    listByProjectId(projectId: UuidV7, dbExecutor?: DbExecutor): Promise<StepExecutionEntity[]>;
+    loadClaimableByProjectId(projectId: UuidV7, limit: number, now: Date, dbExecutor?: DbExecutor, workItemId?: string): Promise<StepExecutionEntity[]>;
+    create(stepExecution: StepExecutionEntity, dbExecutor?: DbExecutor): Promise<StepExecutionEntity>;
+    claim(stepExecutionId: UuidV7, claim: {
+        workerId: string;
+        claimToken: string;
+        claimedAt: Date;
+        startedAt: Date;
+        leaseExpiresAt: Date;
+        executionDeadlineAt?: Date | null | undefined;
+    }, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
+    heartbeat(stepExecutionId: UuidV7, claimToken: string, heartbeat: {
+        lastHeartbeatAt: Date;
+        leaseExpiresAt: Date;
+    }, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
+    save(stepExecution: StepExecutionEntity, dbExecutor?: DbExecutor): Promise<StepExecutionEntity>;
+    saveMany(stepExecutions: StepExecutionEntity[], dbExecutor?: DbExecutor): Promise<StepExecutionEntity[]>;
+    addResult(stepExecutionResult: StepExecutionResultEntity, dbExecutor?: DbExecutor): Promise<StepExecutionResultEntity>;
+    replaceSignals(stepExecutionResultId: UuidV7, signals: StepSignalEntity[], dbExecutor?: DbExecutor): Promise<StepSignalEntity[]>;
+};

package/dist/packages/core/src/pipeline-executions/step-execution/contracts/step-execution-contracts.d.ts

@@ -0,0 +1,325 @@
+import { z } from "zod";
+export declare const stepSignalSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepExecutionResultId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    key: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        array: "array";
+    }>;
+    source: z.ZodEnum<{
+        extracted: "extracted";
+        computed: "computed";
+    }>;
+    valueJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+    sourcePath: z.ZodNullable<z.ZodString>;
+    computedFromSignalKeys: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const stepExecutionResultSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepExecutionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    attempt: z.ZodNumber;
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+    errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
+    signals: z.ZodArray<z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        stepExecutionResultId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        key: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        source: z.ZodEnum<{
+            extracted: "extracted";
+            computed: "computed";
+        }>;
+        valueJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+        sourcePath: z.ZodNullable<z.ZodString>;
+        computedFromSignalKeys: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const stepExecutionSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepDefinitionVersion: z.ZodNumber;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+        skipped: "skipped";
+        timeout: "timeout";
+        abandoned: "abandoned";
+    }>;
+    inputJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
+    claimedBy: z.ZodNullable<z.ZodString>;
+    claimedAt: z.ZodNullable<z.ZodISODateTime>;
+    lastHeartbeatAt: z.ZodNullable<z.ZodISODateTime>;
+    leaseExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+    executionTimeoutSeconds: z.ZodNullable<z.ZodNumber>;
+    executionDeadlineAt: z.ZodNullable<z.ZodISODateTime>;
+    startedAt: z.ZodNullable<z.ZodISODateTime>;
+    completedAt: z.ZodNullable<z.ZodISODateTime>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        stepExecutionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        attempt: z.ZodNumber;
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+        errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
+        signals: z.ZodArray<z.ZodObject<{
+            id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+            stepExecutionResultId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+            key: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            source: z.ZodEnum<{
+                extracted: "extracted";
+                computed: "computed";
+            }>;
+            valueJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+            sourcePath: z.ZodNullable<z.ZodString>;
+            computedFromSignalKeys: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const createStepExecutionInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    stepDefinitionVersion: z.ZodNumber;
+    inputJson: z.ZodOptional<z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+        skipped: "skipped";
+        timeout: "timeout";
+        abandoned: "abandoned";
+    }>>;
+    executionTimeoutSeconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const stepExecutionClaimSchema: z.ZodObject<{
+    stepExecution: z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        stepDefinitionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        stepDefinitionVersion: z.ZodNumber;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            skipped: "skipped";
+            timeout: "timeout";
+            abandoned: "abandoned";
+        }>;
+        inputJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
+        claimedBy: z.ZodNullable<z.ZodString>;
+        claimedAt: z.ZodNullable<z.ZodISODateTime>;
+        lastHeartbeatAt: z.ZodNullable<z.ZodISODateTime>;
+        leaseExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+        executionTimeoutSeconds: z.ZodNullable<z.ZodNumber>;
+        executionDeadlineAt: z.ZodNullable<z.ZodISODateTime>;
+        startedAt: z.ZodNullable<z.ZodISODateTime>;
+        completedAt: z.ZodNullable<z.ZodISODateTime>;
+        results: z.ZodArray<z.ZodObject<{
+            id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+            stepExecutionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+            attempt: z.ZodNumber;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+            }>;
+            resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+            errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
+            signals: z.ZodArray<z.ZodObject<{
+                id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+                stepExecutionResultId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+                key: z.ZodString;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    array: "array";
+                }>;
+                source: z.ZodEnum<{
+                    extracted: "extracted";
+                    computed: "computed";
+                }>;
+                valueJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+                sourcePath: z.ZodNullable<z.ZodString>;
+                computedFromSignalKeys: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                createdAt: z.ZodISODateTime;
+            }, z.core.$strip>>;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    claimToken: z.ZodString;
+}, z.core.$strip>;
+export declare const claimStepExecutionsInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    workerId: z.ZodString;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    leaseDurationSeconds: z.ZodDefault<z.ZodNumber>;
+    workItemId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const stepExecutionClaimCommandInputSchema: z.ZodObject<{
+    claimToken: z.ZodString;
+    leaseDurationSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const getStepExecutionWorkerContextInputSchema: z.ZodObject<{
+    claimToken: z.ZodString;
+}, z.core.$strip>;
+export declare const stepExecutionWorkerContextSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    gitUrl: z.ZodString;
+    requestedBranch: z.ZodNullable<z.ZodString>;
+    projectOpencodeConfig: z.ZodObject<{
+        relativePath: z.ZodString;
+        present: z.ZodBoolean;
+        commands: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            run: z.ZodString;
+            cwd: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        services: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            run: z.ZodString;
+            cwd: z.ZodNullable<z.ZodString>;
+            dependsOn: z.ZodArray<z.ZodString>;
+            expose: z.ZodObject<{
+                targetPort: z.ZodNumber;
+                protocol: z.ZodEnum<{
+                    tcp: "tcp";
+                    http: "http";
+                }>;
+            }, z.core.$strip>;
+            healthcheck: z.ZodObject<{
+                protocol: z.ZodEnum<{
+                    tcp: "tcp";
+                    http: "http";
+                }>;
+                path: z.ZodNullable<z.ZodString>;
+                expectedStatus: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    stepExecution: z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+            skipped: "skipped";
+            timeout: "timeout";
+            abandoned: "abandoned";
+        }>;
+        inputJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
+        executionTimeoutSeconds: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    stepDefinition: z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        key: z.ZodString;
+        name: z.ZodString;
+        prompt: z.ZodString;
+        resultSchemaJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonObject, unknown>>>;
+        opencodeMcpJson: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"local">;
+            command: z.ZodArray<z.ZodString>;
+            environment: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            timeout: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"remote">;
+            url: z.ZodString;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            oauth: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                clientId: z.ZodOptional<z.ZodString>;
+                clientSecret: z.ZodOptional<z.ZodString>;
+                scope: z.ZodOptional<z.ZodString>;
+                redirectUri: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodLiteral<false>]>>;
+            timeout: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>, z.ZodObject<{
+            enabled: z.ZodBoolean;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strip>;
+    agentPrompt: z.ZodObject<{
+        sessionTitle: z.ZodString;
+        promptText: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const completeClaimedStepExecutionInputSchema: z.ZodObject<{
+    claimToken: z.ZodString;
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+    errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
+}, z.core.$strip>;
+export declare const addStepExecutionResultInputSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    stepExecutionId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    attempt: z.ZodNumber;
+    resultJson: z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>;
+    errorJson: z.ZodNullable<z.ZodType<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/json").AnyJsonValue, unknown>>>;
+}, z.core.$strip>;
+export declare const getStepExecutionInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+export declare const getStepExecutionResultInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+export declare const listStepExecutionsByProjectIdInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+export type StepSignalContract = z.infer<typeof stepSignalSchema>;
+export type StepExecutionResultContract = z.infer<typeof stepExecutionResultSchema>;
+export type StepExecutionContract = z.infer<typeof stepExecutionSchema>;
+export type StepExecutionClaimContract = z.infer<typeof stepExecutionClaimSchema>;
+export type CreateStepExecutionInput = z.input<typeof createStepExecutionInputSchema>;
+export type AddStepExecutionResultInput = z.input<typeof addStepExecutionResultInputSchema>;
+export type ClaimStepExecutionsInput = z.input<typeof claimStepExecutionsInputSchema>;
+export type StepExecutionClaimCommandInput = z.input<typeof stepExecutionClaimCommandInputSchema>;
+export type GetStepExecutionWorkerContextInput = z.input<typeof getStepExecutionWorkerContextInputSchema>;
+export type CompleteClaimedStepExecutionInput = z.input<typeof completeClaimedStepExecutionInputSchema>;
+export type GetStepExecutionInput = z.input<typeof getStepExecutionInputSchema>;
+export type GetStepExecutionResultInput = z.input<typeof getStepExecutionResultInputSchema>;
+export type ListStepExecutionsByProjectIdInput = z.input<typeof listStepExecutionsByProjectIdInputSchema>;
+export type StepExecutionWorkerContextContract = z.infer<typeof stepExecutionWorkerContextSchema>;

package/dist/packages/core/src/pipeline-executions/step-execution/domain/step-execution-entity.d.ts

@@ -0,0 +1,61 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import { StepExecutionResultEntity, type StepExecutionResultEntityProps } from "../entities/step-execution-result-entity";
+import type { AnyJsonValue } from "@boboddy/core/common/contracts/json";
+export declare const stepExecutionStatusValues: readonly ["queued", "running", "succeeded", "failed", "timeout", "abandoned", "cancelled", "skipped"];
+export type StepExecutionStatus = (typeof stepExecutionStatusValues)[number];
+export type StepExecutionEntityProps = {
+    id: UuidV7;
+    projectId: UuidV7;
+    stepDefinitionId: UuidV7;
+    stepDefinitionVersion: number;
+    status: StepExecutionStatus;
+    inputJson?: AnyJsonValue | null | undefined;
+    claimedBy?: string | null | undefined;
+    claimToken?: string | null | undefined;
+    claimedAt?: Date | string | null | undefined;
+    lastHeartbeatAt?: Date | string | null | undefined;
+    leaseExpiresAt?: Date | string | null | undefined;
+    executionTimeoutSeconds?: number | null | undefined;
+    executionDeadlineAt?: Date | string | null | undefined;
+    startedAt?: Date | string | null | undefined;
+    completedAt?: Date | string | null | undefined;
+    results?: readonly StepExecutionResultEntityProps[] | undefined;
+    createdAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export type CreateStepExecutionEntityProps = Omit<StepExecutionEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class StepExecutionEntity {
+    readonly id: UuidV7;
+    readonly projectId: UuidV7;
+    readonly stepDefinitionId: UuidV7;
+    readonly stepDefinitionVersion: number;
+    readonly status: StepExecutionStatus;
+    readonly inputJson: AnyJsonValue | null;
+    readonly claimedBy: string | null;
+    readonly claimToken: string | null;
+    readonly claimedAt: Date | null | undefined;
+    readonly lastHeartbeatAt: Date | null | undefined;
+    readonly leaseExpiresAt: Date | null | undefined;
+    readonly executionTimeoutSeconds: number | null;
+    readonly executionDeadlineAt: Date | null | undefined;
+    readonly startedAt: Date | null | undefined;
+    readonly completedAt: Date | null | undefined;
+    readonly results: StepExecutionResultEntity[];
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateStepExecutionEntityProps): StepExecutionEntity;
+    static rehydrate(props: StepExecutionEntityProps): StepExecutionEntity;
+    markRunning(now: Date): StepExecutionEntity;
+    isLeaseExpired(now: Date): boolean;
+    isTimedOut(now: Date): boolean;
+    reconcileLiveness(now: Date): StepExecutionEntity;
+    withStatus(status: StepExecutionStatus, now: Date, overrides?: {
+        startedAt?: Date | null | undefined;
+        completedAt?: Date | null | undefined;
+        clearClaim?: boolean | undefined;
+    }): StepExecutionEntity;
+    toJSON(): StepExecutionEntityProps;
+}

package/dist/packages/core/src/pipeline-executions/step-execution/domain/step-signal-created.domain-event.d.ts

@@ -0,0 +1,18 @@
+import type { AnyJsonValue } from "@boboddy/core/common/contracts/json";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { DomainEvent } from "@boboddy/core/lib/domain-events/domain-event";
+import type { StepSignalType } from "../entities/step-signal-entity";
+export declare const STEP_SIGNAL_CREATED_DOMAIN_EVENT_TYPE = "step_signal.created";
+export type StepSignalCreatedPayload = {
+    stepSignalId: UuidV7;
+    stepExecutionResultId: UuidV7;
+    key: string;
+    type: StepSignalType;
+    valueJson: AnyJsonValue;
+};
+export declare class StepSignalCreatedDomainEvent implements DomainEvent<typeof STEP_SIGNAL_CREATED_DOMAIN_EVENT_TYPE, StepSignalCreatedPayload> {
+    readonly payload: StepSignalCreatedPayload;
+    readonly type = "step_signal.created";
+    readonly occurredAt: Date;
+    constructor(payload: StepSignalCreatedPayload, occurredAt?: Date);
+}