@shipfox/api-workflows 2.0.0

package/src/db/workflow-runs/run-status.ts

@@ -0,0 +1,391 @@
+import {
+  WORKFLOWS_WORKFLOW_RUN_CANCELLED,
+  WORKFLOWS_WORKFLOW_RUN_TERMINATED,
+} from '@shipfox/api-workflows-dto';
+import {and, asc, eq, inArray, notInArray, sql} from 'drizzle-orm';
+import {isJobTerminal, type Job, type JobStatusReason} from '#core/entities/job.js';
+import {
+  isWorkflowRunTerminal,
+  type WorkflowRun,
+  type WorkflowRunStatus,
+} from '#core/entities/workflow-run.js';
+import {WorkflowRunNotCancellableError, WorkflowRunNotFoundError} from '#core/errors.js';
+import {recordWorkflowJobStatusChanged, recordWorkflowRunStatusChanged} from '#metrics/instance.js';
+import {db, type Tx} from '../db.js';
+import {writeWorkflowsOutboxEvent} from '../outbox-writes.js';
+import {jobExecutions} from '../schema/job-executions.js';
+import {jobs} from '../schema/jobs.js';
+import {steps} from '../schema/steps.js';
+import {workflowRunAttempts} from '../schema/workflow-run-attempts.js';
+import {toWorkflowRun, workflowRuns} from '../schema/workflow-runs.js';
+import {updateJobStatusAtVersion} from './jobs.js';
+import {
+  lockWorkflowRun,
+  TERMINAL_EXECUTION_STATUSES,
+  TERMINAL_WORKFLOW_RUN_STATUSES,
+} from './shared.js';
+import {bulkUpdateStepStatuses} from './steps.js';
+
+export interface CancelWorkflowRunParams {
+  workflowRunId: string;
+}
+
+export interface FailWorkflowRunAsTimedOutParams {
+  runAttemptId: string;
+}
+
+export interface RunTerminationSpec {
+  terminalStatus: Extract<WorkflowRunStatus, 'failed' | 'cancelled'>;
+  statusReason: Extract<JobStatusReason, 'timed_out' | 'run_cancelled'>;
+  markExecutionTimedOut: boolean;
+  emitCancelledEvent: boolean;
+}
+
+/**
+ * Shared terminal transition for a run attempt. The caller locks the run and the
+ * attempt (and decides how an already-terminal run is handled: timeout returns
+ * idempotently, cancellation rejects), then this drives every non-terminal job,
+ * execution, and step to `spec.terminalStatus`, resolves still-listening jobs,
+ * flips the attempt and run, and writes the outbox. Callers record metrics after
+ * the transaction commits.
+ */
+async function terminateRunAttempt(
+  tx: Tx,
+  params: {
+    lockedRun: typeof workflowRuns.$inferSelect;
+    lockedAttempt: typeof workflowRunAttempts.$inferSelect;
+    spec: RunTerminationSpec;
+  },
+): Promise<{run: WorkflowRun; changedJobs: Job[]}> {
+  const {lockedRun, lockedAttempt, spec} = params;
+
+  const runJobExecutionIds = tx
+    .select({id: jobExecutions.id})
+    .from(jobExecutions)
+    .innerJoin(jobs, eq(jobExecutions.jobId, jobs.id))
+    .where(eq(jobs.workflowRunAttemptId, lockedAttempt.id));
+
+  await tx
+    .select({id: steps.id})
+    .from(steps)
+    .where(inArray(steps.jobExecutionId, runJobExecutionIds))
+    .orderBy(asc(steps.jobExecutionId), asc(steps.position))
+    .for('update');
+
+  const jobRows = await tx
+    .select()
+    .from(jobs)
+    .where(eq(jobs.workflowRunAttemptId, lockedAttempt.id))
+    .orderBy(asc(jobs.position), asc(jobs.id))
+    .for('update');
+
+  const changedJobs: Job[] = [];
+  for (const jobRow of jobRows) {
+    if (isJobTerminal(jobRow.status)) continue;
+
+    const updated = await updateJobStatusAtVersion(tx, {
+      jobId: jobRow.id,
+      status: spec.terminalStatus,
+      expectedVersion: jobRow.version,
+      statusReason: spec.statusReason,
+    });
+    if (updated?.changed) changedJobs.push(updated.job);
+
+    if (jobRow.mode === 'listening') {
+      await tx
+        .update(jobs)
+        .set({listenerStatus: 'resolved', resolutionReason: 'cancelled', updatedAt: new Date()})
+        .where(eq(jobs.id, jobRow.id));
+    }
+
+    const terminatedExecutions = await tx
+      .update(jobExecutions)
+      .set({
+        status: spec.terminalStatus,
+        statusReason: spec.statusReason,
+        version: sql`${jobExecutions.version} + 1`,
+        updatedAt: new Date(),
+        finishedAt: sql`now()`,
+        ...(spec.markExecutionTimedOut ? {timedOutAt: sql`now()`} : {}),
+      })
+      .where(
+        and(
+          eq(jobExecutions.jobId, jobRow.id),
+          notInArray(jobExecutions.status, TERMINAL_EXECUTION_STATUSES),
+        ),
+      )
+      .returning({id: jobExecutions.id});
+    for (const jobExecution of terminatedExecutions) {
+      await bulkUpdateStepStatuses(
+        {jobExecutionId: jobExecution.id, status: spec.terminalStatus},
+        tx,
+      );
+    }
+  }
+
+  await tx
+    .update(workflowRunAttempts)
+    .set({
+      status: spec.terminalStatus,
+      version: sql`${workflowRunAttempts.version} + 1`,
+      updatedAt: new Date(),
+      finishedAt: sql`now()`,
+    })
+    .where(
+      and(
+        eq(workflowRunAttempts.id, lockedAttempt.id),
+        notInArray(workflowRunAttempts.status, TERMINAL_WORKFLOW_RUN_STATUSES),
+      ),
+    );
+
+  const [terminatedRunRow] = await tx
+    .update(workflowRuns)
+    .set({
+      status: spec.terminalStatus,
+      version: sql`${workflowRuns.version} + 1`,
+      updatedAt: new Date(),
+      finishedAt: sql`now()`,
+    })
+    .where(
+      and(
+        eq(workflowRuns.id, lockedRun.id),
+        notInArray(workflowRuns.status, TERMINAL_WORKFLOW_RUN_STATUSES),
+      ),
+    )
+    .returning();
+
+  const run = toWorkflowRun(terminatedRunRow ?? lockedRun);
+  await writeWorkflowsOutboxEvent(tx, {
+    type: WORKFLOWS_WORKFLOW_RUN_TERMINATED,
+    payload: {
+      workflowRunId: run.id,
+      workflowRunAttemptId: lockedAttempt.id,
+      projectId: run.projectId,
+      status: spec.terminalStatus,
+    },
+  });
+  if (spec.emitCancelledEvent) {
+    await writeWorkflowsOutboxEvent(tx, {
+      type: WORKFLOWS_WORKFLOW_RUN_CANCELLED,
+      payload: {
+        workflowRunId: run.id,
+        workflowRunAttemptId: lockedAttempt.id,
+        projectId: run.projectId,
+      },
+    });
+  }
+
+  return {run, changedJobs};
+}
+
+export async function failWorkflowRunAsTimedOut(
+  params: FailWorkflowRunAsTimedOutParams,
+): Promise<WorkflowRun> {
+  const result = await db().transaction(async (tx) => {
+    const [lockedAttempt] = await tx
+      .select()
+      .from(workflowRunAttempts)
+      .where(eq(workflowRunAttempts.id, params.runAttemptId))
+      .limit(1)
+      .for('update');
+    if (!lockedAttempt) throw new WorkflowRunNotFoundError(params.runAttemptId);
+
+    const lockedRun = await lockWorkflowRun(lockedAttempt.workflowRunId, tx);
+    if (!lockedRun) throw new WorkflowRunNotFoundError(lockedAttempt.workflowRunId);
+    if (isWorkflowRunTerminal(lockedRun.status)) {
+      return {run: toWorkflowRun(lockedRun), changedJobs: [], changed: false};
+    }
+
+    const result = await terminateRunAttempt(tx, {
+      lockedRun,
+      lockedAttempt,
+      spec: {
+        terminalStatus: 'failed',
+        statusReason: 'timed_out',
+        markExecutionTimedOut: true,
+        emitCancelledEvent: false,
+      },
+    });
+    return {...result, changed: true};
+  });
+
+  if (result.changed) recordWorkflowRunStatusChanged(result.run.status);
+  for (const job of result.changedJobs) recordWorkflowJobStatusChanged(job.status);
+  return result.run;
+}
+
+export async function cancelWorkflowRun(params: CancelWorkflowRunParams): Promise<WorkflowRun> {
+  const result = await db().transaction(async (tx) => {
+    const lockedRun = await lockWorkflowRun(params.workflowRunId, tx);
+
+    if (!lockedRun) {
+      throw new WorkflowRunNotFoundError(params.workflowRunId);
+    }
+    if (isWorkflowRunTerminal(lockedRun.status)) {
+      throw new WorkflowRunNotCancellableError(lockedRun.id, lockedRun.status);
+    }
+
+    const [lockedAttempt] = await tx
+      .select()
+      .from(workflowRunAttempts)
+      .where(
+        and(
+          eq(workflowRunAttempts.workflowRunId, lockedRun.id),
+          eq(workflowRunAttempts.attempt, lockedRun.currentAttempt),
+        ),
+      )
+      .limit(1)
+      .for('update');
+    if (!lockedAttempt) {
+      throw new Error(
+        `Current attempt ${lockedRun.currentAttempt} missing for run ${lockedRun.id}`,
+      );
+    }
+
+    return terminateRunAttempt(tx, {
+      lockedRun,
+      lockedAttempt,
+      spec: {
+        terminalStatus: 'cancelled',
+        statusReason: 'run_cancelled',
+        markExecutionTimedOut: false,
+        emitCancelledEvent: true,
+      },
+    });
+  });
+
+  recordWorkflowRunStatusChanged(result.run.status);
+  for (const job of result.changedJobs) recordWorkflowJobStatusChanged(job.status);
+
+  return result.run;
+}
+
+export interface UpdateWorkflowRunStatusParams {
+  workflowRunId?: string;
+  workflowRunAttemptId?: string;
+  status: WorkflowRunStatus;
+  expectedVersion: number;
+}
+
+export async function updateWorkflowRunStatus(
+  params: UpdateWorkflowRunStatusParams,
+): Promise<WorkflowRun> {
+  const result = await db().transaction(async (tx) => {
+    const [attemptRef] = params.workflowRunAttemptId
+      ? await tx
+          .select({
+            id: workflowRunAttempts.id,
+            workflowRunId: workflowRunAttempts.workflowRunId,
+          })
+          .from(workflowRunAttempts)
+          .where(eq(workflowRunAttempts.id, params.workflowRunAttemptId))
+          .limit(1)
+      : [];
+
+    const workflowRunId = attemptRef?.workflowRunId ?? params.workflowRunId ?? '';
+    const lockedRun = await lockWorkflowRun(workflowRunId, tx);
+
+    if (!lockedRun) {
+      throw new WorkflowRunNotFoundError(params.workflowRunId ?? params.workflowRunAttemptId ?? '');
+    }
+
+    const [lockedAttempt] = await tx
+      .select()
+      .from(workflowRunAttempts)
+      .where(
+        params.workflowRunAttemptId
+          ? eq(workflowRunAttempts.id, params.workflowRunAttemptId)
+          : and(
+              eq(workflowRunAttempts.workflowRunId, lockedRun.id),
+              eq(workflowRunAttempts.attempt, lockedRun.currentAttempt),
+            ),
+      )
+      .limit(1)
+      .for('update');
+
+    if (!lockedAttempt) {
+      throw new WorkflowRunNotFoundError(params.workflowRunId ?? params.workflowRunAttemptId ?? '');
+    }
+
+    const target = {run: lockedRun, attempt: lockedAttempt};
+
+    const rows = await tx
+      .update(workflowRunAttempts)
+      .set({
+        status: params.status,
+        version: sql`${workflowRunAttempts.version} + 1`,
+        updatedAt: new Date(),
+        ...(params.status === 'running'
+          ? {startedAt: sql`coalesce(${workflowRunAttempts.startedAt}, now())`}
+          : {}),
+        ...(isWorkflowRunTerminal(params.status) ? {finishedAt: sql`now()`} : {}),
+      })
+      .where(
+        and(
+          eq(workflowRunAttempts.id, target.attempt.id),
+          eq(workflowRunAttempts.version, params.expectedVersion),
+          notInArray(workflowRunAttempts.status, TERMINAL_WORKFLOW_RUN_STATUSES),
+        ),
+      )
+      .returning();
+
+    const attemptRow = rows[0];
+    if (!attemptRow) {
+      const existing = await tx
+        .select()
+        .from(workflowRunAttempts)
+        .where(eq(workflowRunAttempts.id, target.attempt.id))
+        .limit(1);
+      const existingRow = existing[0];
+      if (
+        existingRow &&
+        (existingRow.status === params.status || isWorkflowRunTerminal(existingRow.status))
+      ) {
+        return {
+          run: {...toWorkflowRun(target.run), version: existingRow.version},
+          changed: false,
+        };
+      }
+      throw new Error(
+        `Optimistic lock failure: run attempt ${target.attempt.id} version ${params.expectedVersion}`,
+      );
+    }
+
+    const shouldMirror = target.run.currentAttempt === attemptRow.attempt;
+    const [runRow] = shouldMirror
+      ? await tx
+          .update(workflowRuns)
+          .set({
+            status: params.status,
+            version: sql`${workflowRuns.version} + 1`,
+            updatedAt: new Date(),
+            ...(params.status === 'running'
+              ? {startedAt: sql`coalesce(${workflowRuns.startedAt}, now())`}
+              : {}),
+            ...(isWorkflowRunTerminal(params.status) ? {finishedAt: sql`now()`} : {}),
+          })
+          .where(eq(workflowRuns.id, target.run.id))
+          .returning()
+      : [target.run];
+
+    const run = {...toWorkflowRun(runRow ?? target.run), version: attemptRow.version};
+
+    if (shouldMirror && isWorkflowRunTerminal(run.status)) {
+      await writeWorkflowsOutboxEvent(tx, {
+        type: WORKFLOWS_WORKFLOW_RUN_TERMINATED,
+        payload: {
+          workflowRunId: run.id,
+          workflowRunAttemptId: attemptRow.id,
+          projectId: run.projectId,
+          status: run.status,
+        },
+      });
+    }
+
+    return {run, changed: true};
+  });
+
+  if (result.changed) recordWorkflowRunStatusChanged(result.run.status);
+
+  return result.run;
+}

package/src/db/workflow-runs/runs.ts

@@ -0,0 +1,17 @@
+export type {CreateWorkflowRunParams} from './run-create.js';
+export {
+  createWorkflowRun,
+  loadReferencedVariables,
+} from './run-create.js';
+export type {CreateRerunWorkflowRunParams} from './run-rerun.js';
+export {createRerunWorkflowRun} from './run-rerun.js';
+export type {
+  CancelWorkflowRunParams,
+  FailWorkflowRunAsTimedOutParams,
+  UpdateWorkflowRunStatusParams,
+} from './run-status.js';
+export {
+  cancelWorkflowRun,
+  failWorkflowRunAsTimedOut,
+  updateWorkflowRunStatus,
+} from './run-status.js';

package/src/db/workflow-runs/shared.ts

@@ -0,0 +1,84 @@
+import {eq, sql} from 'drizzle-orm';
+import type {JobStatus} from '#core/entities/job.js';
+import type {JobExecutionStatus} from '#core/entities/job-execution.js';
+import type {WorkflowRunStatus} from '#core/entities/workflow-run.js';
+import type {Tx} from '../db.js';
+import {jobs} from '../schema/jobs.js';
+import {steps} from '../schema/steps.js';
+import {workflowRunAttempts} from '../schema/workflow-run-attempts.js';
+import {workflowRuns} from '../schema/workflow-runs.js';
+
+export const TERMINAL_WORKFLOW_RUN_STATUSES: WorkflowRunStatus[] = [
+  'succeeded',
+  'failed',
+  'cancelled',
+];
+
+export const TERMINAL_JOB_STATUSES: JobStatus[] = ['succeeded', 'failed', 'cancelled', 'skipped'];
+
+export const TERMINAL_EXECUTION_STATUSES: JobExecutionStatus[] = [
+  'succeeded',
+  'failed',
+  'cancelled',
+];
+
+export const NON_TERMINAL_STEP_STATUS_FILTER = sql`${steps.status} NOT IN ('succeeded','failed','cancelled','skipped')`;
+
+export async function lockWorkflowRun(
+  id: string,
+  tx: Tx,
+): Promise<typeof workflowRuns.$inferSelect | undefined> {
+  const rows = await tx
+    .select()
+    .from(workflowRuns)
+    .where(eq(workflowRuns.id, id))
+    .limit(1)
+    .for('update');
+  return rows[0];
+}
+
+export async function optimisticLockRetry<TResult, TFetched>(params: {
+  updateFn: () => Promise<TResult | null>;
+  fetchFn: () => Promise<TFetched | undefined>;
+  matchFn: (value: TFetched) => TResult | null;
+  failureMessage: string;
+}): Promise<TResult> {
+  const updated = await params.updateFn();
+  if (updated) return updated;
+
+  const existing = await params.fetchFn();
+  if (existing) {
+    const matched = params.matchFn(existing);
+    if (matched) return matched;
+  }
+
+  throw new Error(params.failureMessage);
+}
+
+export async function getWorkflowContextForJob(
+  jobId: string,
+  tx: Tx,
+): Promise<{
+  jobId: string;
+  workflowRunId: string;
+  workflowRunAttemptId: string;
+  workspaceId: string;
+  projectId: string;
+}> {
+  const rows = await tx
+    .select({
+      jobId: jobs.id,
+      workflowRunId: workflowRuns.id,
+      workflowRunAttemptId: workflowRunAttempts.id,
+      workspaceId: workflowRuns.workspaceId,
+      projectId: workflowRuns.projectId,
+    })
+    .from(jobs)
+    .innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id))
+    .innerJoin(workflowRuns, eq(workflowRunAttempts.workflowRunId, workflowRuns.id))
+    .where(eq(jobs.id, jobId))
+    .limit(1);
+  const context = rows[0];
+  if (!context) throw new Error(`Cannot load workflow context: job ${jobId} not found`);
+  return context;
+}

package/src/db/workflow-runs/steps.test.ts

@@ -0,0 +1,191 @@
+import {eq} from 'drizzle-orm';
+import {nextStepForJob} from '#core/job-execution.js';
+import {stripSetupStep} from '#test/fixtures/strip-setup-step.js';
+import {
+  buildModel,
+  bulkUpdateJobStepStatuses,
+  stepAttemptTerminatedEvents,
+} from '#test/helpers/workflow-runs.js';
+import {db} from '../db.js';
+import {stepAttempts as stepAttemptsTable} from '../schema/step-attempts.js';
+import {steps as stepsTable} from '../schema/steps.js';
+import {
+  createWorkflowRun,
+  getJobsByWorkflowRunId,
+  getStepAttempts,
+  getStepsByJobId,
+} from '../workflow-runs.js';
+
+describe('workflow run queries', () => {
+  let workspaceId: string;
+  let projectId: string;
+  let definitionId: string;
+
+  beforeEach(() => {
+    workspaceId = crypto.randomUUID();
+    projectId = crypto.randomUUID();
+    definitionId = crypto.randomUUID();
+  });
+
+  describe('getStepsByJobId', () => {
+    test('returns steps for a job ordered by position', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {
+            build: {
+              steps: [{run: 'step1'}, {run: 'step2'}, {run: 'step3'}],
+            },
+          },
+        }),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+
+      const runJobs = await getJobsByWorkflowRunId(run.id);
+      const jobSteps = await getStepsByJobId(runJobs[0]?.id as string);
+
+      // The synthetic setup step occupies position 0; user steps follow at 1..3.
+      expect(jobSteps).toHaveLength(4);
+      expect(jobSteps[0]).toMatchObject({type: 'setup', position: 0});
+      expect(jobSteps[1]?.position).toBe(1);
+      expect(jobSteps[2]?.position).toBe(2);
+      expect(jobSteps[3]?.position).toBe(3);
+    });
+  });
+
+  describe('bulkUpdateStepStatuses', () => {
+    test('updates all steps for a job to the given sweep status', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({
+          jobs: {
+            build: {steps: [{run: 'step1'}, {run: 'step2'}, {run: 'step3'}]},
+          },
+        }),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+      const runJobs = await getJobsByWorkflowRunId(run.id);
+
+      const jobId = runJobs[0]?.id ?? '';
+      await bulkUpdateJobStepStatuses({jobId, status: 'failed'});
+
+      const jobSteps = await getStepsByJobId(jobId);
+      expect(jobSteps).toHaveLength(4);
+      for (const step of jobSteps) {
+        expect(step.status).toBe('failed');
+      }
+    });
+
+    test('does not downgrade a terminal step (terminal-state guard)', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'a'}, {run: 'b'}]}}}),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+      const runJobs = await getJobsByWorkflowRunId(run.id);
+      const jobId = runJobs[0]?.id ?? '';
+      const seeded = await getStepsByJobId(jobId);
+
+      await db()
+        .update(stepsTable)
+        .set({status: 'succeeded'})
+        .where(eq(stepsTable.id, seeded[0]?.id as string));
+      await db()
+        .update(stepsTable)
+        .set({status: 'skipped', statusReason: 'condition_rejected'})
+        .where(eq(stepsTable.id, seeded[1]?.id as string));
+
+      await bulkUpdateJobStepStatuses({jobId, status: 'failed'});
+
+      const final = await getStepsByJobId(jobId);
+      expect(final[0]?.status).toBe('succeeded');
+      expect(final[1]?.status).toBe('skipped');
+      expect(final[1]?.statusReason).toBe('condition_rejected');
+    });
+
+    test('step attempts cannot be skipped', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'a'}]}}}),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+      const runJobs = await getJobsByWorkflowRunId(run.id);
+      const jobId = runJobs[0]?.id ?? '';
+      const [step] = await getStepsByJobId(jobId);
+      if (!step) throw new Error('Expected arranged step');
+
+      await expect(
+        db().insert(stepAttemptsTable).values({
+          stepId: step.id,
+          jobExecutionId: step.jobExecutionId,
+          attempt: 1,
+          executionOrder: 1,
+          status: 'skipped',
+        }),
+      ).rejects.toThrow();
+    });
+
+    test('terminal sweeps finalize running attempts as abandoned and emit attempt events', async () => {
+      const run = await createWorkflowRun({
+        workspaceId,
+        projectId,
+        definitionId,
+        model: buildModel({jobs: {build: {steps: [{run: 'a'}]}}}),
+        triggerPayload: {
+          source: 'manual',
+          event: 'fire',
+          subscriptionId: crypto.randomUUID(),
+          userId: crypto.randomUUID(),
+        },
+      });
+      const runJobs = await getJobsByWorkflowRunId(run.id);
+      const jobId = runJobs[0]?.id ?? '';
+      await stripSetupStep(jobId);
+      await nextStepForJob(jobId);
+
+      await bulkUpdateJobStepStatuses({jobId, status: 'cancelled'});
+
+      const [attempt] = await getStepAttempts(jobId);
+      expect(attempt).toMatchObject({status: 'cancelled', logOutcome: 'abandoned'});
+      expect(await stepAttemptTerminatedEvents(jobId)).toMatchObject([
+        {
+          jobId,
+          workflowRunId: run.id,
+          workspaceId,
+          projectId,
+          stepId: attempt?.stepId,
+          attempt: 1,
+          logOutcome: 'abandoned',
+        },
+      ]);
+    });
+  });
+});