From 35e37dac09d2863b9274824c39a9b2be640ebd92 Mon Sep 17 00:00:00 2001 From: Janpeter Visser <30029041+madhura68@users.noreply.github.com> Date: Sat, 9 May 2026 13:59:06 +0200 Subject: [PATCH] feat(ST-006): voeg restartClaudeJobAction toe aan actions/claude-jobs.ts (#174) - Exporteert restartClaudeJobAction(jobId) die FAILED/CANCELLED/SKIPPED jobs atomair reset naar QUEUED - Valideert auth, demo-blokkade, ownership en restartbare status - Gebruikt prisma.$transaction: claudeJob.updateMany + conditionale sprintTaskExecution.updateMany reset - Verstuurt pg_notify claude_job_status zodat Jobs-pagina via SSE ververst - Unit-tests: happy-path (FAILED/CANCELLED/SKIPPED), demo-blokkade, not-found, niet-restartbare status, race-conditie en sprint sub-task reset --- __tests__/actions/claude-jobs.test.ts | 147 ++++++++++++++++++++++++-- actions/claude-jobs.ts | 77 ++++++++++++++ 2 files changed, 218 insertions(+), 6 deletions(-) diff --git a/__tests__/actions/claude-jobs.test.ts b/__tests__/actions/claude-jobs.test.ts index 5e95878..484f185 100644 --- a/__tests__/actions/claude-jobs.test.ts +++ b/__tests__/actions/claude-jobs.test.ts @@ -8,13 +8,24 @@ const { mockGetSession, mockFindFirstJob, mockUpdateJob, + mockUpdateManyJob, + mockUpdateManySprintTaskExecution, + mockTransaction, mockExecuteRaw, -} = vi.hoisted(() => ({ - mockGetSession: vi.fn(), - mockFindFirstJob: vi.fn(), - mockUpdateJob: vi.fn(), - mockExecuteRaw: vi.fn().mockResolvedValue(undefined), -})) +} = vi.hoisted(() => { + const mockUpdateManyJob = vi.fn() + const mockUpdateManySprintTaskExecution = vi.fn() + const mockTransaction = vi.fn() + return { + mockGetSession: vi.fn(), + mockFindFirstJob: vi.fn(), + mockUpdateJob: vi.fn(), + mockUpdateManyJob, + mockUpdateManySprintTaskExecution, + mockTransaction, + mockExecuteRaw: vi.fn().mockResolvedValue(undefined), + } +}) vi.mock('next/cache', () => ({ revalidatePath: vi.fn() })) vi.mock('@/lib/auth', () => ({ getSession: mockGetSession })) @@ -23,7 +34,12 @@ vi.mock('@/lib/prisma', () => ({ claudeJob: { findFirst: mockFindFirstJob, update: mockUpdateJob, + updateMany: mockUpdateManyJob, }, + sprintTaskExecution: { + updateMany: mockUpdateManySprintTaskExecution, + }, + $transaction: mockTransaction, $executeRaw: mockExecuteRaw, }, })) @@ -32,6 +48,7 @@ import { enqueueClaudeJobAction, enqueueAllTodoJobsAction, cancelClaudeJobAction, + restartClaudeJobAction, } from '@/actions/claude-jobs' const SESSION_USER = { userId: 'user-1', isDemo: false } @@ -39,6 +56,12 @@ const SESSION_USER = { userId: 'user-1', isDemo: false } beforeEach(() => { vi.clearAllMocks() mockExecuteRaw.mockResolvedValue(undefined) + mockTransaction.mockImplementation(async (fn: (tx: unknown) => Promise) => + fn({ + claudeJob: { updateMany: mockUpdateManyJob }, + sprintTaskExecution: { updateMany: mockUpdateManySprintTaskExecution }, + }) + ) }) describe('enqueueClaudeJobAction (deprecated)', () => { @@ -104,3 +127,115 @@ describe('cancelClaudeJobAction', () => { expect(result).toMatchObject({ error: expect.stringContaining('actieve') }) }) }) + +describe('restartClaudeJobAction', () => { + const FAILED_JOB = { + id: 'job-1', + status: 'FAILED', + kind: 'TASK_IMPLEMENTATION', + task_id: 'task-1', + idea_id: null, + sprint_run_id: null, + product_id: 'prod-1', + } + + it('reset een FAILED job naar QUEUED (happy path)', async () => { + mockGetSession.mockResolvedValue(SESSION_USER) + mockFindFirstJob.mockResolvedValue(FAILED_JOB) + mockUpdateManyJob.mockResolvedValue({ count: 1 }) + + const result = await restartClaudeJobAction('job-1') + + expect(result).toEqual({ success: true }) + expect(mockUpdateManyJob).toHaveBeenCalledWith( + expect.objectContaining({ + where: expect.objectContaining({ id: 'job-1', status: { in: ['FAILED', 'CANCELLED', 'SKIPPED'] } }), + data: expect.objectContaining({ status: 'QUEUED' }), + }) + ) + expect(mockExecuteRaw).toHaveBeenCalled() + }) + + it('reset een CANCELLED job naar QUEUED', async () => { + mockGetSession.mockResolvedValue(SESSION_USER) + mockFindFirstJob.mockResolvedValue({ ...FAILED_JOB, status: 'CANCELLED' }) + mockUpdateManyJob.mockResolvedValue({ count: 1 }) + + const result = await restartClaudeJobAction('job-1') + expect(result).toEqual({ success: true }) + }) + + it('reset een SKIPPED job naar QUEUED', async () => { + mockGetSession.mockResolvedValue(SESSION_USER) + mockFindFirstJob.mockResolvedValue({ ...FAILED_JOB, status: 'SKIPPED' }) + mockUpdateManyJob.mockResolvedValue({ count: 1 }) + + const result = await restartClaudeJobAction('job-1') + expect(result).toEqual({ success: true }) + }) + + it('weigert demo-sessie', async () => { + mockGetSession.mockResolvedValue({ userId: 'demo', isDemo: true }) + + const result = await restartClaudeJobAction('job-1') + expect(result).toMatchObject({ error: expect.stringContaining('demo') }) + expect(mockUpdateManyJob).not.toHaveBeenCalled() + }) + + it('retourneert error als job niet gevonden', async () => { + mockGetSession.mockResolvedValue(SESSION_USER) + mockFindFirstJob.mockResolvedValue(null) + + const result = await restartClaudeJobAction('job-1') + expect(result).toMatchObject({ error: expect.stringContaining('niet gevonden') }) + }) + + it('weigert wanneer job een niet-restartbare status heeft', async () => { + mockGetSession.mockResolvedValue(SESSION_USER) + mockFindFirstJob.mockResolvedValue({ ...FAILED_JOB, status: 'DONE' }) + + const result = await restartClaudeJobAction('job-1') + expect(result).toMatchObject({ error: expect.stringContaining('mislukte') }) + expect(mockUpdateManyJob).not.toHaveBeenCalled() + }) + + it('retourneert error bij race-conditie (updateMany count === 0)', async () => { + mockGetSession.mockResolvedValue(SESSION_USER) + mockFindFirstJob.mockResolvedValue(FAILED_JOB) + mockUpdateManyJob.mockResolvedValue({ count: 0 }) + + const result = await restartClaudeJobAction('job-1') + expect(result).toMatchObject({ error: expect.stringContaining('gewijzigd') }) + }) + + it('reset ook SprintTaskExecution-rows bij SPRINT_IMPLEMENTATION', async () => { + mockGetSession.mockResolvedValue(SESSION_USER) + mockFindFirstJob.mockResolvedValue({ + ...FAILED_JOB, + kind: 'SPRINT_IMPLEMENTATION', + sprint_run_id: 'run-1', + }) + mockUpdateManyJob.mockResolvedValue({ count: 1 }) + mockUpdateManySprintTaskExecution.mockResolvedValue({ count: 3 }) + + const result = await restartClaudeJobAction('job-1') + + expect(result).toEqual({ success: true }) + expect(mockUpdateManySprintTaskExecution).toHaveBeenCalledWith( + expect.objectContaining({ + where: { sprint_job_id: 'job-1' }, + data: expect.objectContaining({ status: 'PENDING' }), + }) + ) + }) + + it('reset geen SprintTaskExecution-rows bij TASK_IMPLEMENTATION', async () => { + mockGetSession.mockResolvedValue(SESSION_USER) + mockFindFirstJob.mockResolvedValue(FAILED_JOB) + mockUpdateManyJob.mockResolvedValue({ count: 1 }) + + await restartClaudeJobAction('job-1') + + expect(mockUpdateManySprintTaskExecution).not.toHaveBeenCalled() + }) +}) diff --git a/actions/claude-jobs.ts b/actions/claude-jobs.ts index 12fa3e9..258fd1a 100644 --- a/actions/claude-jobs.ts +++ b/actions/claude-jobs.ts @@ -1,6 +1,7 @@ 'use server' import { revalidatePath } from 'next/cache' +import { type ClaudeJobStatus } from '@prisma/client' import { prisma } from '@/lib/prisma' import { getSession } from '@/lib/auth' import { ACTIVE_JOB_STATUSES, jobStatusToApi } from '@/lib/job-status' @@ -15,6 +16,9 @@ type EnqueueAllResult = type CancelResult = { success: true } | { error: string } +type RestartResult = { success: true } | { error: string } +const RESTARTABLE_STATUSES: ClaudeJobStatus[] = ['FAILED', 'CANCELLED', 'SKIPPED'] + export type PreviewTask = { id: string title: string @@ -109,3 +113,76 @@ export async function cancelClaudeJobAction(jobId: string): Promise { + const session = await getSession() + if (!session.userId) return { error: 'Niet ingelogd' } + if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' } + if (!jobId) return { error: 'job_id is verplicht' } + + const job = await prisma.claudeJob.findFirst({ + where: { id: jobId, user_id: session.userId }, + select: { id: true, status: true, kind: true, task_id: true, idea_id: true, sprint_run_id: true, product_id: true }, + }) + if (!job) return { error: 'Job niet gevonden' } + if (!RESTARTABLE_STATUSES.includes(job.status)) { + return { error: 'Alleen mislukte, geannuleerde of overgeslagen jobs kunnen opnieuw gestart worden' } + } + + const updated = await prisma.$transaction(async (tx) => { + const result = await tx.claudeJob.updateMany({ + where: { id: jobId, status: { in: RESTARTABLE_STATUSES } }, + data: { + status: 'QUEUED', + retry_count: { increment: 1 }, + claimed_by_token_id: null, + claimed_at: null, + started_at: null, + finished_at: null, + pushed_at: null, + verify_result: null, + error: null, + summary: null, + branch: null, + head_sha: null, + lease_until: null, + }, + }) + if (result.count === 0) return 0 + if (job.kind === 'SPRINT_IMPLEMENTATION') { + await tx.sprintTaskExecution.updateMany({ + where: { sprint_job_id: jobId }, + data: { + status: 'PENDING', + verify_result: null, + verify_summary: null, + skip_reason: null, + head_sha: null, + started_at: null, + finished_at: null, + }, + }) + } + return result.count + }) + if (updated === 0) { + return { error: 'Job-status is gewijzigd; herlaad en probeer opnieuw' } + } + + await prisma.$executeRaw` + SELECT pg_notify('scrum4me_changes', ${JSON.stringify({ + type: 'claude_job_status', + job_id: jobId, + kind: job.kind, + task_id: job.task_id, + idea_id: job.idea_id, + sprint_run_id: job.sprint_run_id, + user_id: session.userId, + product_id: job.product_id, + status: jobStatusToApi('QUEUED'), + })}::text) + ` + + revalidatePath('/jobs') + return { success: true } +}