fix(orchestration): atomically queue approvals with optional not-before schedule
Deploy Canina / deploy (push) Successful in 4m56s

This commit is contained in:
devops committed 2026-10-24 06:16:20 +00:00
1 parent ab2f330eb8
commit 50d0df822c
15 files changed
+216 -65

No files matched your search

@@ -249,15 +249,10 @@ export class PrepareWorkflowService {
throw new ForbiddenException(
'Gate2 decisions and release remain disabled',
);
if (
!['APPROVED', 'REJECTED'].includes(dto.decision) ||
!Number.isFinite(Date.parse(dto.expiresAt)) ||
Date.parse(dto.expiresAt) <= Date.now() ||
Date.parse(dto.expiresAt) > Date.now() + 86400000
)
throw new BadRequestException(
'Decision requires future expiry within 24 hours',
);
if (!['APPROVED', 'REJECTED'].includes(dto.decision))
throw new BadRequestException('Invalid decision');
// Time-sensitive validation happens after replay, so a successful command
// remains replayable after its original schedule or validity window passes.
return this.db.$transaction(async (tx: any) => {
await this.allowed(tx);
const t = await this.task(tx, id);
@@ -268,20 +263,37 @@ export class PrepareWorkflowService {
throw new ForbiddenException('Independent reviewer required');
if (!['GATE1_PENDING', 'GATE1_HELD'].includes(t.state))
throw new ConflictException('Gate1 pending required');
const now = Date.now();
const scheduled = dto.notBefore !== undefined;
const notBefore = scheduled ? new Date(dto.notBefore) : null;
if (scheduled && (dto.decision !== 'APPROVED' || typeof dto.notBefore !== 'string' || !Number.isFinite(notBefore!.getTime()) || notBefore!.getTime() <= now || notBefore!.getTime() > now + 30 * 86400000))
throw new BadRequestException('notBefore must be a future approval schedule within 30 days');
const policyExpiry = (notBefore?.getTime() ?? now) + 86400000;
// Legacy expiresAt is an explicit validity cap, never a scheduled start.
const expiresAt = dto.expiresAt === undefined ? new Date(policyExpiry) : new Date(dto.expiresAt);
if (!Number.isFinite(expiresAt.getTime()) || expiresAt.getTime() <= (notBefore?.getTime() ?? now) || expiresAt.getTime() > policyExpiry)
throw new BadRequestException('Approval expiry must cover schedule and remain within backend validity policy');
if (dto.notes !== undefined && (typeof dto.notes !== 'string' || dto.notes.length > 2000))
throw new BadRequestException('Audit notes must be at most 2000 characters');
if (dto.decision === 'APPROVED') {
await this.allowed(tx, true);
await tx.prepareWorkflowOutbox.create({data:{taskId:id,notBefore}});
}
await tx.orchestrationApprovalDecision.create({
data: {
taskId: id,
gate: 1,
decision: dto.decision,
actorId: a.id,
expiresAt: new Date(dto.expiresAt),
expiresAt,
notes: dto.notes?.trim() || `Owner ${dto.decision.toLowerCase()} Gate1`,
idempotencyKey: `decision:${dto.idempotencyKey}`,
},
});
return this.event(
tx,
t,
dto.decision === 'APPROVED' ? 'GATE1_APPROVED' : 'REJECTED',
dto.decision === 'APPROVED' ? 'READY' : 'REJECTED',
a,
dto.idempotencyKey,
'PREPARE_GATE1',
@@ -289,14 +301,32 @@ export class PrepareWorkflowService {
);
});
}
/** Recovery of a stored approval by its provisioned proposal worker, not a new decision. */
async enqueueApproved(a: WorkflowIdentity, dto: {taskId:string;expectedVersion:number;idempotencyKey:string}) {
this.worker(a);
return this.db.$transaction(async (tx:any)=>{
await this.allowed(tx,true);
const t=await this.task(tx,dto.taskId);
if(t.metadata.createdBy!==a.id) throw new ForbiddenException('Proposal worker required');
const fingerprint=JSON.stringify({dto,a});
if(await this.replay(tx,dto.idempotencyKey,fingerprint)) return t;
this.version(t,dto);
if(t.state!=='GATE1_APPROVED') throw new ConflictException('Stored Gate1 approval required');
const approval=await tx.orchestrationApprovalDecision.findFirst({where:{taskId:t.id,gate:1},orderBy:{createdAt:'desc'}});
if(!approval || approval.decision!=='APPROVED' || approval.actorId===a.id || approval.expiresAt<=new Date())
throw new ForbiddenException('Valid independent Gate1 required');
await tx.prepareWorkflowOutbox.create({data:{taskId:t.id}});
return this.event(tx,t,'READY',a,dto.idempotencyKey,'PREPARE_APPROVED_QUEUED',fingerprint);
});
}
async claim(a: WorkflowIdentity, id?: string): Promise<any> {
this.worker(a);
return this.db.$transaction(async (tx: any) => {
await this.allowed(tx, true);
// Lock order is task then outbox for every worker operation. SKIP LOCKED permits competing workers.
const rows: any[] = id
? await tx.$queryRaw`SELECT t.id FROM orchestration_tasks t JOIN prepare_workflow_outbox o ON o.task_id=t.id WHERE t.id=${id}::uuid AND o.status='PENDING' AND (o.lease_until IS NULL OR o.lease_until < now()) ORDER BY o.created_at FOR UPDATE OF t SKIP LOCKED LIMIT 1`
: await tx.$queryRaw`SELECT t.id FROM orchestration_tasks t JOIN prepare_workflow_outbox o ON o.task_id=t.id WHERE o.status='PENDING' AND (o.lease_until IS NULL OR o.lease_until < now()) ORDER BY o.created_at FOR UPDATE OF t SKIP LOCKED LIMIT 1`;
? await tx.$queryRaw`SELECT t.id FROM orchestration_tasks t JOIN prepare_workflow_outbox o ON o.task_id=t.id WHERE t.id=${id}::uuid AND t.state IN ('READY','RUNNING') AND o.status='PENDING' AND (o.not_before IS NULL OR o.not_before <= now()) AND (o.lease_until IS NULL OR o.lease_until < now()) ORDER BY o.created_at FOR UPDATE OF t SKIP LOCKED LIMIT 1`
: await tx.$queryRaw`SELECT t.id FROM orchestration_tasks t JOIN prepare_workflow_outbox o ON o.task_id=t.id WHERE t.state IN ('READY','RUNNING') AND o.status='PENDING' AND (o.not_before IS NULL OR o.not_before <= now()) AND (o.lease_until IS NULL OR o.lease_until < now()) ORDER BY o.created_at FOR UPDATE OF t SKIP LOCKED LIMIT 1`;
if (!rows.length) return null;
const t = await this.task(tx, rows[0].id);
const o = await tx.prepareWorkflowOutbox.findUnique({