@shipfox/api-workflows 10.2.0 → 12.0.0

package/src/temporal/workflows/job-execution-orchestration.test.ts

@@ -67,6 +67,21 @@ function finalStatusesFor(jobId: string): string[] {
     .map((c) => c.params.status);
 }
 
+async function waitForExecutionStatus(jobExecutionId: string, status: string): Promise<void> {
+  for (let attempt = 0; attempt < 40; attempt += 1) {
+    if (
+      setExecutionStatusCalls().some(
+        (call) => call.params.jobExecutionId === jobExecutionId && call.params.status === status,
+      )
+    ) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+
+  throw new Error(`Timed out waiting for ${jobExecutionId} to reach ${status}`);
+}
+
 function terminalSetJobCall(jobId: string) {
   return setExecutionStatusCalls().find(
     (call) => call.params.jobExecutionId === jobId && call.params.status !== 'running',
@@ -92,7 +107,7 @@ async function expectEmptyRequiredLabelsFailure(input: typeof defaultJobInput):
 }
 
 describe('jobExecutionOrchestration', () => {
-  test('finished signal (succeeded) flips status and releases the lease', async () => {
+  test('runner claim flips status to running, then finished releases the lease', async () => {
     setCfg({
       dag: makeDag([dagJob('job-1', 'build')]),
       jobResults: new Map([['job-1', 'succeeded']]),
@@ -107,6 +122,109 @@ describe('jobExecutionOrchestration', () => {
     expect(callsNamed('bulkSetStepStatuses')).toHaveLength(0);
   });
 
+  test('keeps an execution pending until the current runner claim', async () => {
+    setCfg({dag: makeDag([]), jobResults: new Map(), skipSignal: true});
+
+    const handle = await testEnv.client.workflow.start('jobExecutionOrchestration', {
+      taskQueue: TASK_QUEUE,
+      workflowId: 'job:job-pending-before-claim',
+      args: [
+        {
+          ...defaultJobInput,
+          jobId: 'job-pending-before-claim',
+          jobExecutionId: 'job-pending-before-claim',
+        },
+      ],
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(setExecutionStatusCalls()).toHaveLength(0);
+
+    await handle.signal('job-claimed', {
+      jobExecutionId: 'job-pending-before-claim',
+      claimedAt: '2026-06-22T10:05:00.000Z',
+    });
+    await waitForExecutionStatus('job-pending-before-claim', 'running');
+    await handle.signal('job-finished', {
+      jobExecutionId: 'job-pending-before-claim',
+      status: 'succeeded',
+    });
+
+    const result = await handle.result();
+    expect(result.status).toBe('succeeded');
+    expect(finalStatusesFor('job-pending-before-claim')).toEqual(['running', 'succeeded']);
+  });
+
+  test('ignores stale and duplicate claims and transitions exactly once', async () => {
+    setCfg({dag: makeDag([]), jobResults: new Map(), skipSignal: true});
+
+    const handle = await testEnv.client.workflow.start('jobExecutionOrchestration', {
+      taskQueue: TASK_QUEUE,
+      workflowId: 'job:job-claim-idempotent',
+      args: [
+        {
+          ...defaultJobInput,
+          jobId: 'job-claim-idempotent',
+          jobExecutionId: 'execution-current',
+        },
+      ],
+    });
+
+    await handle.signal('job-claimed', {
+      jobExecutionId: 'execution-stale',
+      claimedAt: '2026-06-22T10:04:00.000Z',
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(setExecutionStatusCalls()).toHaveLength(0);
+
+    const claim = {
+      jobExecutionId: 'execution-current',
+      claimedAt: '2026-06-22T10:05:00.000Z',
+    };
+    await handle.signal('job-claimed', claim);
+    await handle.signal('job-claimed', {...claim, claimedAt: '2026-06-22T10:06:00.000Z'});
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    await handle.signal('job-finished', {
+      jobExecutionId: 'execution-current',
+      status: 'succeeded',
+    });
+
+    const result = await handle.result();
+    expect(result.status).toBe('succeeded');
+    expect(finalStatusesFor('execution-current')).toEqual(['running', 'succeeded']);
+  });
+
+  test('a finish before a delayed claim remains terminal', async () => {
+    setCfg({dag: makeDag([]), jobResults: new Map(), skipSignal: true});
+
+    const handle = await testEnv.client.workflow.start('jobExecutionOrchestration', {
+      taskQueue: TASK_QUEUE,
+      workflowId: 'job:job-finish-before-claim',
+      args: [
+        {
+          ...defaultJobInput,
+          jobId: 'job-finish-before-claim',
+          jobExecutionId: 'job-finish-before-claim',
+        },
+      ],
+    });
+
+    await handle.signal('job-finished', {
+      jobExecutionId: 'job-finish-before-claim',
+      status: 'succeeded',
+    });
+    const result = await handle.result();
+
+    expect(result.status).toBe('succeeded');
+    expect(finalStatusesFor('job-finish-before-claim')).toEqual(['succeeded']);
+    await expect(
+      handle.signal('job-claimed', {
+        jobExecutionId: 'job-finish-before-claim',
+        claimedAt: '2026-06-22T10:05:00.000Z',
+      }),
+    ).rejects.toThrow();
+  });
+
   test('empty required labels fail before the job is marked running', async () => {
     setCfg({
       dag: makeDag([dagJob('job-empty-labels', 'build')]),
@@ -272,7 +390,7 @@ describe('jobExecutionOrchestration', () => {
     ]);
   }, 15_000);
 
-  test('already-terminal job is not enqueued', async () => {
+  test('already-terminal job is not reopened after a claim', async () => {
     setCfg({
       dag: makeDag([]),
       jobResults: new Map(),
@@ -282,7 +400,7 @@ describe('jobExecutionOrchestration', () => {
     const result = await executeJob({...defaultJobInput, jobId: 'job-cancelled'});
 
     expect(result).toMatchObject({status: 'cancelled'});
-    expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(0);
+    expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(1);
     expect(callsNamed('releaseLeaseActivity')).toHaveLength(0);
   });
 
@@ -314,7 +432,7 @@ describe('jobExecutionOrchestration', () => {
 
     expect(result.status).toBe('failed');
     expect(callsNamed('failJobExecutionAsTimedOutActivity')).toHaveLength(1);
-    expect(finalStatusesFor('job-timeout')).toEqual(['running']);
+    expect(finalStatusesFor('job-timeout')).toEqual([]);
     expect(callsNamed('bulkSetStepStatuses')).toContainEqual({
       name: 'bulkSetStepStatuses',
       params: {jobExecutionId: 'job-timeout', status: 'failed'},
@@ -323,6 +441,24 @@ describe('jobExecutionOrchestration', () => {
     expect(callsNamed('resolveLeaseExpiredJobExecutionActivity')).toHaveLength(0);
   });
 
+  test('does not reset the execution deadline after claim', async () => {
+    setCfg({
+      dag: makeDag([dagJob('job-claim-timeout', 'build')]),
+      jobResults: new Map(),
+      skipOutcomeSignal: true,
+    });
+
+    const result = await executeJob({
+      ...defaultJobInput,
+      jobId: 'job-claim-timeout',
+      executionTimeoutMs: 250,
+    });
+
+    expect(result.status).toBe('failed');
+    expect(finalStatusesFor('job-claim-timeout')).toEqual(['running']);
+    expect(callsNamed('failJobExecutionAsTimedOutActivity')).toHaveLength(1);
+  });
+
   test('surfaces a timeout activity failure', async () => {
     setCfg({
       dag: makeDag([dagJob('job-timeout-error', 'build')]),
@@ -339,10 +475,10 @@ describe('jobExecutionOrchestration', () => {
       }),
     ).rejects.toThrow();
 
-    expect(finalStatusesFor('job-timeout-error')).toEqual(['running']);
+    expect(finalStatusesFor('job-timeout-error')).toEqual([]);
   });
 
-  test('no signal — workflow stays blocked indefinitely', async () => {
+  test('no signal: workflow stays blocked indefinitely', async () => {
     setCfg({dag: makeDag([]), jobResults: new Map(), skipSignal: true});
 
     const handle = await testEnv.client.workflow.start('jobExecutionOrchestration', {

package/src/temporal/workflows/job-execution-orchestration.ts

@@ -9,25 +9,25 @@ import {
 import type {RuntimeCompletionStatus} from '#core/workflow-scheduling/runtime-dag.js';
 
 import type {createOrchestrationActivities} from '../activities/index.js';
-import {JOB_FINISHED_SIGNAL, JOB_LEASE_EXPIRED_SIGNAL} from '../constants.js';
+import {JOB_CLAIMED_SIGNAL, JOB_FINISHED_SIGNAL, JOB_LEASE_EXPIRED_SIGNAL} from '../constants.js';
+import {remainingMs} from './deadline.js';
 
 /**
- * Two signals, one precedence ladder, then best-effort lease release:
+ * Enqueue, wait for the runner claim, then wait for one of the terminal facts:
  *
- *   job-finished (recordStepResult exhausted the steps) ─┐
- *   job-lease-expired (runner heartbeat went stale) ─────┤
- *                                                        ▼
- *   condition(finished ∥ leaseExpired, executionTimeout)
- *     ├─ finished      → setJobExecutionStatus(status) + resolve job status     ─┐
- *     ├─ leaseExpired  → resolveLeaseExpiredJobExecutionActivity                 ─┤→ releaseLease
- *     └─ neither (6h)  → failJobExecutionAsTimedOutActivity + sweep steps (NO release; the
- *                        TIMED_OUT event drives cooperative cancel, the detector reaps)
+ *   enqueue ──> PENDING ── job-claimed ──> RUNNING
+ *                 │                          │
+ *                 │ timeout                  ├─ job-finished
+ *                 │                          ├─ job-lease-expired
+ *                 ▼                          └─ timeout
+ *              TERMINAL
  *
- * Both signals can be delivered before condition() resumes (independent outboxes,
- * no ordering), so finished is evaluated FIRST: a genuinely-finished job is never
- * flipped to failed by a late lease-expiry. releaseLease is best-effort — a runners
- * DB outage must never block the child workflow from returning the job outcome to
- * run-orchestration; a leftover lease row is reaped by the stuck detector.
+ * The claim signal is the runner-owned lifecycle boundary. The workflow keeps the
+ * execution pending while it is queued, then performs the versioned pending → running
+ * transition after the current claim. One deadline spans both waits; claim never resets
+ * it. Signals can arrive in any order, so the precedence is finished > lease expired >
+ * claimed > timeout. Lease cleanup remains best-effort: a runners DB outage must never
+ * block the child workflow from returning the job outcome to run-orchestration.
  */
 
 const {
@@ -64,6 +64,11 @@ export const jobFinishedSignal =
   );
 export const jobLeaseExpiredSignal =
   defineSignal<[{jobExecutionId?: string | undefined}]>(JOB_LEASE_EXPIRED_SIGNAL);
+export interface JobClaimedSignalPayload {
+  jobExecutionId: string;
+  claimedAt: string;
+}
+export const jobClaimedSignal = defineSignal<[JobClaimedSignalPayload]>(JOB_CLAIMED_SIGNAL);
 
 export interface JobExecutionOrchestrationInput {
   workspaceId: string;
@@ -116,12 +121,7 @@ async function resolveJobStatusOrFailClosed(
   }
 }
 
-async function markJobExecutionRunningAndEnqueue(
-  input: JobExecutionOrchestrationInput,
-): Promise<
-  | {kind: 'running'; runningVersion: number}
-  | {kind: 'terminal'; result: JobExecutionOrchestrationResult}
-> {
+async function enqueueJobExecution(input: JobExecutionOrchestrationInput): Promise<void> {
   if (hasNoRequiredRunnerLabels(input.requiredLabels)) {
     throw ApplicationFailure.nonRetryable(
       `Job ${input.jobId} has no required runner labels`,
@@ -129,15 +129,6 @@ async function markJobExecutionRunningAndEnqueue(
     );
   }
 
-  const {newVersion: runningVersion, status} = await setJobExecutionStatus({
-    jobExecutionId: input.jobExecutionId,
-    status: 'running',
-    version: input.executionVersion,
-  });
-
-  const start = jobExecutionStartOutcome({newVersion: runningVersion, status});
-  if (start.kind === 'terminal') return start;
-
   await enqueueJobExecutionForRunner({
     workspaceId: input.workspaceId,
     workflowRunId: input.workflowRunId,
@@ -147,30 +138,59 @@ async function markJobExecutionRunningAndEnqueue(
     projectId: input.projectId,
     requiredLabels: input.requiredLabels,
   });
+}
+
+async function markJobExecutionRunning(
+  input: JobExecutionOrchestrationInput,
+): Promise<
+  | {kind: 'running'; runningVersion: number}
+  | {kind: 'terminal'; result: JobExecutionOrchestrationResult}
+> {
+  const {newVersion: runningVersion, status} = await setJobExecutionStatus({
+    jobExecutionId: input.jobExecutionId,
+    status: 'running',
+    version: input.executionVersion,
+  });
 
+  const start = jobExecutionStartOutcome({newVersion: runningVersion, status});
+  if (start.kind === 'terminal') return start;
   return {kind: 'running', runningVersion};
 }
 
-// Both signals can arrive before condition() resumes (independent outboxes, no
-// ordering), so callers must evaluate `finished` before `leaseExpired`.
-async function awaitJobOutcome(
+interface JobExecutionSignals extends JobExecutionOutcomeSignals {
+  claimed: JobClaimedSignalPayload | undefined;
+}
+
+function registerJobExecutionSignalHandlers(
   jobExecutionId: string,
-  timeoutMs: number,
-): Promise<JobExecutionOutcomeSignals> {
-  let finished: {status: RuntimeCompletionStatus; jobExecutionId?: string | undefined} | undefined;
-  let leaseExpired = false;
+  signals: JobExecutionSignals,
+): void {
   setHandler(jobFinishedSignal, (payload) => {
     if (payload.jobExecutionId !== undefined && payload.jobExecutionId !== jobExecutionId) return;
-    finished ??= payload;
+    signals.finished ??= payload;
   });
   setHandler(jobLeaseExpiredSignal, (payload = {}) => {
     if (payload.jobExecutionId !== undefined && payload.jobExecutionId !== jobExecutionId) return;
-    leaseExpired = true;
+    signals.leaseExpired = true;
   });
+  setHandler(jobClaimedSignal, (payload) => {
+    if (payload.jobExecutionId !== jobExecutionId) return;
+    signals.claimed ??= payload;
+  });
+}
 
-  await condition(() => finished !== undefined || leaseExpired, timeoutMs);
-
-  return {finished, leaseExpired};
+async function waitForJobExecutionSignal(
+  signals: JobExecutionSignals,
+  deadline: number,
+  includeClaim: boolean,
+): Promise<void> {
+  await condition(
+    () =>
+      signals.finished !== undefined ||
+      signals.leaseExpired ||
+      (includeClaim && signals.claimed !== undefined),
+    remainingMs(deadline) ?? 0,
+  );
 }
 
 interface JobExecutionResolution {
@@ -286,7 +306,41 @@ async function resolveTimedOutJobExecution({
 export async function jobExecutionOrchestration(
   input: JobExecutionOrchestrationInput,
 ): Promise<JobExecutionOrchestrationResult> {
-  const running = await markJobExecutionRunningAndEnqueue(input);
+  const signals: JobExecutionSignals = {
+    finished: undefined,
+    leaseExpired: false,
+    claimed: undefined,
+  };
+  // Register every signal before enqueue can block or publish a claim/outcome event. The
+  // handlers retain signals that arrive while the enqueue activity is in flight.
+  registerJobExecutionSignalHandlers(input.jobExecutionId, signals);
+  await enqueueJobExecution(input);
+
+  const timeoutMs = input.executionTimeoutMs ?? DEFAULT_EXECUTION_MAX_DURATION_MS;
+  const deadline = Date.now() + timeoutMs;
+  await waitForJobExecutionSignal(signals, deadline, true);
+
+  // A terminal fact wins over claim even when both signals arrive before the condition
+  // resumes. This prevents a late claim from reopening an execution that already finished.
+  let resolution = resolveJobExecutionOutcomeSignal(signals);
+  if (resolution === 'finished') {
+    const {finished} = signals;
+    if (finished === undefined) throw new Error('Missing finished signal for finished resolution');
+
+    return resolveFinishedJobExecution({
+      input,
+      runningVersion: input.executionVersion,
+      status: finished.status,
+    });
+  }
+  if (resolution === 'lease-expired') {
+    return resolveLeaseExpiredJobExecution({input, runningVersion: input.executionVersion});
+  }
+  if (!signals.claimed) {
+    return resolveTimedOutJobExecution({input, runningVersion: input.executionVersion});
+  }
+
+  const running = await markJobExecutionRunning(input);
   if (running.kind === 'terminal') {
     if (input.resolveJobStatus === false) {
       return {status: running.result.status, jobVersion: input.jobVersion};
@@ -295,16 +349,11 @@ export async function jobExecutionOrchestration(
   }
   const {runningVersion} = running;
 
-  const timeoutMs = input.executionTimeoutMs ?? DEFAULT_EXECUTION_MAX_DURATION_MS;
-  const signals = await awaitJobOutcome(input.jobExecutionId, timeoutMs);
-
-  // Precedence ladder: a genuinely-finished job is never flipped to failed by a
-  // late lease-expiry, so `finished` wins over `leaseExpired`.
-  const resolution = resolveJobExecutionOutcomeSignal(signals);
+  await waitForJobExecutionSignal(signals, deadline, false);
+  resolution = resolveJobExecutionOutcomeSignal(signals);
   if (resolution === 'finished') {
     const {finished} = signals;
     if (finished === undefined) throw new Error('Missing finished signal for finished resolution');
-
     return resolveFinishedJobExecution({input, runningVersion, status: finished.status});
   }
   if (resolution === 'lease-expired') {

package/src/temporal/workflows/run-orchestration.test.ts

@@ -382,7 +382,7 @@ describe('runOrchestration', () => {
     const runAttemptStatuses = setRunAttemptStatusCalls().map((c) => c.params.status);
     expect(runAttemptStatuses).toEqual(['running', 'failed']);
 
-    // A, B, C enqueued — D skipped because B failed
+    // A, B, C enqueued: D skipped because B failed
     expect(callsNamed('enqueueJobExecutionForRunner')).toHaveLength(3);
     const jobStatuses = setJobStatusCalls().map((c) => ({
       id: c.params.jobId,

package/src/temporal/workflows/test-env.ts

@@ -9,7 +9,7 @@ import type {
   ListenerBufferPeek,
 } from '#db/job-listeners.js';
 import type {RunDag} from '../activities/orchestration-activities.js';
-import {JOB_FINISHED_SIGNAL, JOB_LEASE_EXPIRED_SIGNAL} from '../constants.js';
+import {JOB_CLAIMED_SIGNAL, JOB_FINISHED_SIGNAL, JOB_LEASE_EXPIRED_SIGNAL} from '../constants.js';
 
 const TASK_QUEUE = 'test-orchestration';
 const WORKFLOWS_PATH = resolve(import.meta.dirname, '../../../dist/temporal/workflows/index.js');
@@ -17,7 +17,7 @@ const WORKFLOWS_PATH = resolve(import.meta.dirname, '../../../dist/temporal/work
 export {TASK_QUEUE};
 
 // ---------------------------------------------------------------------------
-// Shared mutable test config — each test sets this before starting a workflow.
+// Shared mutable test config: each test sets this before starting a workflow.
 // Activities read from it via closure. Tests run serially within a describe.
 // ---------------------------------------------------------------------------
 
@@ -29,8 +29,12 @@ export interface TestConfig {
   enqueueError?: string;
   /** If true, enqueueJobExecutionForRunner sends two job-finished signals (for dedup testing) */
   duplicateSignal?: boolean;
-  /** If true, enqueueJobExecutionForRunner does nothing (no signal — for timeout testing) */
+  /** If true, enqueueJobExecutionForRunner does nothing without a signal for timeout testing */
   skipSignal?: boolean;
+  /** If true, emit the claim but hold back the terminal outcome (for deadline testing) */
+  skipOutcomeSignal?: boolean;
+  /** Runner-owned claim timestamp used by the mock claim event */
+  claimedAt?: string;
   /** If true, signal job-lease-expired instead of job-finished */
   signalLeaseExpired?: boolean;
   /** If true, signal BOTH job-finished and job-lease-expired (precedence testing) */
@@ -73,6 +77,14 @@ export interface ActivityCall {
 
 export let calls: ActivityCall[];
 let versionSeq: number;
+const pendingJobOutcomes = new Map<
+  string,
+  {
+    handle: ReturnType<typeof testEnv.client.workflow.getHandle>;
+    status: RuntimeCompletionStatus;
+    duplicateSignal: boolean;
+  }
+>();
 
 function nextVersion(): number {
   return ++versionSeq;
@@ -81,6 +93,7 @@ function nextVersion(): number {
 export function resetCalls(): void {
   calls = [];
   versionSeq = 0;
+  pendingJobOutcomes.clear();
 }
 
 export function callsNamed(name: string): ActivityCall[] {
@@ -192,7 +205,7 @@ export async function setupEnv(): Promise<void> {
     activities: createMockActivities(),
   });
 
-  // Run worker in background — it processes tasks until shutdown is called
+  // Run worker in background: it processes tasks until shutdown is called
   workerRunPromise = worker.run();
   workerRunPromise.catch(() => {
     // Suppress unhandled rejection on shutdown
@@ -242,7 +255,7 @@ function createMockActivities() {
       });
     },
 
-    setJobExecutionStatus: (params: {
+    setJobExecutionStatus: async (params: {
       jobExecutionId: string;
       status: string;
       version: number;
@@ -251,6 +264,24 @@ function createMockActivities() {
       calls.push({name: 'setJobExecutionStatus', params});
       const status =
         params.status === 'running' && cfg.runningJobStatus ? cfg.runningJobStatus : params.status;
+
+      if (params.status === 'running') {
+        const outcome = pendingJobOutcomes.get(params.jobExecutionId);
+        pendingJobOutcomes.delete(params.jobExecutionId);
+        if (outcome && status === 'running') {
+          await outcome.handle.signal(JOB_FINISHED_SIGNAL, {
+            status: outcome.status,
+            jobExecutionId: params.jobExecutionId,
+          });
+          if (outcome.duplicateSignal) {
+            await outcome.handle.signal(JOB_FINISHED_SIGNAL, {
+              status: 'failed',
+              jobExecutionId: params.jobExecutionId,
+            });
+          }
+        }
+      }
+
       return {newVersion: nextVersion(), status};
     },
 
@@ -285,6 +316,12 @@ function createMockActivities() {
 
       const status = cfg.jobResults.get(params.jobId) ?? 'succeeded';
       const handle = testEnv.client.workflow.getHandle(`job:${params.jobId}`);
+      await handle.signal(JOB_CLAIMED_SIGNAL, {
+        jobExecutionId: params.jobExecutionId,
+        claimedAt: cfg.claimedAt ?? '2026-06-22T10:05:00.000Z',
+      });
+
+      if (cfg.skipOutcomeSignal) return;
 
       if (cfg.signalLeaseExpired) {
         await handle.signal(JOB_LEASE_EXPIRED_SIGNAL, {jobExecutionId: params.jobExecutionId});
@@ -297,14 +334,14 @@ function createMockActivities() {
         return;
       }
 
-      await handle.signal(JOB_FINISHED_SIGNAL, {status, jobExecutionId: params.jobExecutionId});
-
-      if (cfg.duplicateSignal) {
-        await handle.signal(JOB_FINISHED_SIGNAL, {
-          status: 'failed',
-          jobExecutionId: params.jobExecutionId,
-        });
-      }
+      // The terminal outbox is independent from the claim, but the mock delivers it from the
+      // pending → running activity. This gives the workflow a deterministic ordering boundary
+      // without leaving a polling promise alive after the test finishes.
+      pendingJobOutcomes.set(params.jobExecutionId, {
+        handle,
+        status,
+        duplicateSignal: cfg.duplicateSignal ?? false,
+      });
     },
 
     resolveLeaseExpiredJobExecutionActivity: (params: {

package/test/factories/project.ts

@@ -5,6 +5,7 @@ interface Project {
   workspaceId: string;
   sourceConnectionId: string;
   sourceExternalRepositoryId: string;
+  sourceRepositoryOwner: string | null;
   name: string;
   createdAt: Date;
   updatedAt: Date;
@@ -15,6 +16,7 @@ export const projectFactory = Factory.define<Project>(({sequence}) => ({
   workspaceId: crypto.randomUUID(),
   sourceConnectionId: crypto.randomUUID(),
   sourceExternalRepositoryId: `acme/repo-${sequence}`,
+  sourceRepositoryOwner: 'acme',
   name: `Project ${sequence}`,
   createdAt: new Date(),
   updatedAt: new Date(),