fix(orchestration): expose queued Gate1 expiry and audited renewal
Deploy Canina / deploy (push) Successful in 4m51s

This commit is contained in:
devops authored and devops committed 2026-10-24 09:53:07 +00:00
1 parent 6e465663bd
commit 60a4e14b4b
12 files changed
+162 -12

No files matched your search

@@ -0,0 +1,44 @@
import { PrepareWorkflowService } from './prepare-workflow.service';
describe('queued Gate1 expiry renewal',()=>{
const owner={id:'owner',role:'SUPER_ADMIN'};
let t:any,tx:any,s:PrepareWorkflowService,approval:any;
beforeEach(()=>{
jest.useFakeTimers().setSystemTime(new Date('2026-10-24T09:15:00Z'));
approval={id:'approval',gate:1,decision:'APPROVED',actorId:'owner',createdAt:new Date('2026-10-24T05:37:54.808Z'),expiresAt:new Date('2026-10-24T06:37:00Z')};
t={id:'t',state:'READY',version:4,operationMode:'PREPARE',metadata:{workflowScope:'STAGE_PREPARE',createdBy:'pmo',commitSha:'a'.repeat(40)},decisions:[approval]};
tx={$queryRaw:jest.fn().mockResolvedValue([]),orchestrationTask:{findUnique:jest.fn(async()=>t),update:jest.fn(async({data}:any)=>(t={...t,state:data.state,version:t.version+1}))},orchestrationEvent:{findUnique:jest.fn(),create:jest.fn()},orchestrationApprovalDecision:{findFirst:jest.fn(async()=>approval),create:jest.fn()},prepareWorkflowOutbox:{findUnique:jest.fn().mockResolvedValue({status:'PENDING',attempts:0,runId:null,notBefore:null}),create:jest.fn(),update:jest.fn()}};
s=new PrepareWorkflowService({$transaction:async(fn:any)=>fn(tx)},{workerIds:['pmo'],stageCiIds:[]});
});
afterEach(()=>jest.useRealTimers());
const dto={decision:'APPROVED',expectedVersion:4,idempotencyKey:'renew'};
it('shows blocked renewal rather than actionable READY at actual failure time',()=>{
expect(s.project(t,owner)).toMatchObject({displayState:'GATE1_RENEWAL_REQUIRED',availableActions:['APPROVE_GATE1']});
});
it('renews by ordinary independent approval without recreating outbox or changing immutable task binding',async()=>{
await expect(s.decide('t',1,dto,owner)).resolves.toMatchObject({state:'READY',version:5});
expect(tx.prepareWorkflowOutbox.create).not.toHaveBeenCalled();
expect(tx.orchestrationApprovalDecision.create).toHaveBeenCalledWith({data:expect.objectContaining({actorId:'owner',expiresAt:new Date('2026-10-25T09:15:00Z')})});
expect(tx.orchestrationEvent.create).toHaveBeenCalledWith({data:expect.objectContaining({eventType:'PREPARE_GATE1_RENEWED',fromState:'READY',toState:'READY'})});
});
it('does not renew valid approvals, self review, active runs, or schedule changes',async()=>{
await expect(s.decide('t',1,dto,{id:'pmo',role:'SUPER_ADMIN'})).rejects.toMatchObject({status:403});
await expect(s.decide('t',1,{...dto,notBefore:'2026-10-25T10:00:00Z'},owner)).rejects.toMatchObject({status:400});
tx.prepareWorkflowOutbox.findUnique.mockResolvedValue({status:'PENDING',attempts:1,runId:'r'});
await expect(s.decide('t',1,dto,owner)).rejects.toMatchObject({status:409});
tx.prepareWorkflowOutbox.findUnique.mockResolvedValue({status:'PENDING',attempts:0,runId:null});
approval.expiresAt=new Date('2026-10-25T09:15:00Z');
await expect(s.decide('t',1,dto,owner)).rejects.toMatchObject({status:409});
});
it('replays identical command after expiry but denies changed payload and stale concurrent command',async()=>{
await s.decide('t',1,dto,owner);
const e=tx.orchestrationEvent.create.mock.calls[0][0].data;
tx.orchestrationEvent.findUnique.mockResolvedValue(e);
jest.setSystemTime(new Date('2026-10-26T09:15:00Z'));
await s.decide('t',1,dto,owner);
expect(tx.orchestrationTask.update).toHaveBeenCalledTimes(1);
await expect(s.decide('t',1,{...dto,notes:'changed'},owner)).rejects.toMatchObject({status:409});
tx.orchestrationEvent.findUnique.mockResolvedValue(null);
await expect(s.decide('t',1,{...dto,idempotencyKey:'competing'},owner)).rejects.toMatchObject({status:409});
});
});
@@ -119,6 +119,7 @@ export class OrchestrationController {
return {
...view,
metadata: w.metadata,
displayState: w.displayState,
availableActions: w.availableActions,
};
}
@@ -619,6 +619,7 @@ export class OrchestrationService {
await this.killSwitch.assertAllowed('OBSERVE');
return (this.prisma as any).orchestrationTask.findMany({
orderBy: { createdAt: 'desc' },
include: { decisions: true },
});
}
async findOne(id: string) {
@@ -261,9 +261,24 @@ export class PrepareWorkflowService {
this.version(t, dto);
if (t.metadata.createdBy === a.id)
throw new ForbiddenException('Independent reviewer required');
if (!['GATE1_PENDING', 'GATE1_HELD'].includes(t.state))
const renewing = t.state === 'READY';
let queue: any;
if (renewing) {
const previous = await tx.orchestrationApprovalDecision.findFirst({
where: { taskId: id, gate: 1 }, orderBy: { createdAt: 'desc' },
});
queue = await tx.prepareWorkflowOutbox.findUnique({ where: { taskId: id } });
if (dto.notBefore !== undefined)
throw new BadRequestException('Renewal preserves the existing schedule');
if (dto.decision !== 'APPROVED' || !previous || previous.decision !== 'APPROVED' ||
previous.actorId === t.metadata.createdBy || previous.expiresAt > new Date() ||
!queue || queue.status !== 'PENDING' || queue.attempts !== 0 || queue.runId || queue.leaseToken)
throw new ConflictException('Only expired independent approval on an unstarted queue can be renewed');
} else if (!['GATE1_PENDING', 'GATE1_HELD'].includes(t.state))
throw new ConflictException('Gate1 pending required');
const now = Date.now();
if (renewing && queue.notBefore && new Date(queue.notBefore).getTime() >= now + 86400000)
throw new ConflictException('Existing schedule is outside the renewal validity window');
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))
@@ -277,7 +292,7 @@ export class PrepareWorkflowService {
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}});
if (!renewing) await tx.prepareWorkflowOutbox.create({data:{taskId:id,notBefore}});
}
await tx.orchestrationApprovalDecision.create({
data: {
@@ -296,7 +311,7 @@ export class PrepareWorkflowService {
dto.decision === 'APPROVED' ? 'READY' : 'REJECTED',
a,
dto.idempotencyKey,
'PREPARE_GATE1',
renewing ? 'PREPARE_GATE1_RENEWED' : 'PREPARE_GATE1',
fingerprint,
);
});
@@ -574,7 +589,15 @@ export class PrepareWorkflowService {
(t.metadata?.workflowScope ?? t.metadata?.scope) === 'STAGE_PREPARE';
const owner =
a?.id && (t.metadata?.createdBy === a.id || a.role === 'SUPER_ADMIN');
const latest = [...(t.decisions ?? [])].filter((d: any) => d.gate === 1)
.sort((a: any, b: any) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
const expired = safe && t.state === 'READY' && latest?.decision === 'APPROVED' &&
latest.actorId !== t.metadata.createdBy && new Date(latest.expiresAt).getTime() <= Date.now();
const blocked = safe && t.state === 'READY' && (!latest || latest.decision !== 'APPROVED' ||
latest.actorId === t.metadata.createdBy || new Date(latest.expiresAt).getTime() <= Date.now());
const actions: string[] = [];
if (expired && this.reviewer(a) && t.metadata.createdBy !== a.id)
actions.push('APPROVE_GATE1');
if (safe && owner && t.state === 'DRAFT') actions.push('SUBMIT_GATE1');
if (safe && owner && t.state === 'GATE1_APPROVED')
actions.push('QUEUE_PREPARE');
@@ -589,6 +612,7 @@ export class PrepareWorkflowService {
}
return {
...t,
displayState: blocked ? (expired ? 'GATE1_RENEWAL_REQUIRED' : 'BLOCKED') : t.state,
metadata: safe
? {
scope: t.metadata.scope,
@@ -0,0 +1,24 @@
import { PrismaClient } from '@prisma/client';
import { PrepareWorkflowService } from './prepare-workflow.service';
(process.env.WORKFLOW_DB==='1'?describe:describe.skip)('renewal PostgreSQL serialization',()=>{
const db=new PrismaClient();
const service=new PrepareWorkflowService(db,{workerIds:['pmo'],stageCiIds:[]});
const owner={id:'owner',role:'SUPER_ADMIN'};
afterAll(()=>db.$disconnect());
it('denies expired claim, serializes renewal/replay, retains original decision and enables one claim',async()=>{
const t=await db.orchestrationTask.create({data:{key:crypto.randomUUID(),title:'Disposable renewal',department:'CONTENT',operationMode:'PREPARE',state:'READY',version:4,budgetLimitCents:20,metadata:{workflowScope:'STAGE_PREPARE',createdBy:'pmo',commitSha:'a'.repeat(40)}}});
const old=await db.orchestrationApprovalDecision.create({data:{taskId:t.id,gate:1,decision:'APPROVED',actorId:'owner',expiresAt:new Date('2026-10-24T06:37:00Z'),idempotencyKey:crypto.randomUUID()}});
await db.prepareWorkflowOutbox.create({data:{taskId:t.id}});
const worker={id:'pmo',role:'WORKFLOW_WORKER'};
await expect(service.claim(worker,t.id)).rejects.toMatchObject({status:403});
const dto={expectedVersion:4,decision:'APPROVED',idempotencyKey:crypto.randomUUID()};
const renewed=await Promise.all([service.decide(t.id,1,dto,owner),service.decide(t.id,1,dto,owner)]);
expect(renewed.map(t=>t.version)).toEqual([5,5]);
await expect(service.decide(t.id,1,{...dto,idempotencyKey:crypto.randomUUID()},owner)).rejects.toMatchObject({status:409});
expect(await db.orchestrationApprovalDecision.count({where:{taskId:t.id}})).toBe(2);
expect((await db.orchestrationApprovalDecision.findUniqueOrThrow({where:{id:old.id}})).expiresAt).toEqual(old.expiresAt);
expect(await db.prepareWorkflowOutbox.count({where:{taskId:t.id}})).toBe(1);
const claims=await Promise.all([service.claim(worker,t.id),service.claim(worker,t.id)]);
expect(claims.filter(Boolean)).toHaveLength(1);
});
});