111 lines
9.3 KiB
JavaScript
111 lines
9.3 KiB
JavaScript
import { requestArchived } from './broker.mjs';
|
|
// Host-only admission. The journal's readCandidate/authority/approval adapters read current host state.
|
|
import { exact, id, key, text, digest, refuse } from './request-store.mjs';
|
|
export function createRequirementCatalog({ journal, readSpec, builtinBinding, projectArchived, threadProject }) {
|
|
const append = (state, kind, body) => journal.appendRequest({ business: state.business, request: state.request,
|
|
expectedRevision: state.revision, kind, body, actor: { role: null, run: null } });
|
|
const eventFor = snap => journal.snapshotEvents(snap.business, snap.project).filter(e => e.snapshot === snap.id).at(-1);
|
|
function invalidate(business, project, code, inTransaction = false) {
|
|
return (inTransaction ? journal.compose : journal.transaction)(() => {
|
|
const latest = new Map(journal.snapshotEvents(business, project).map(e => [e.snapshot, e]));
|
|
for (const e of latest.values()) if (e.kind === 'activated') journal.snapshotEvent({ business, project, snapshot: e.snapshot, kind: 'revoked', cause: code });
|
|
for (const row of journal.listRequests()) {
|
|
if (row.business !== business) continue;
|
|
const state = journal.readRequest(business, row.request);
|
|
if (state.project === project && !['complete','delivered','cancelled'].includes(state.phase) && (state.candidate || state.snapshot)) append(state, 'prd.invalidated', { code });
|
|
}
|
|
});
|
|
}
|
|
async function resolve(args) {
|
|
exact(args, ['business','project'], ['snapshot']);
|
|
if (!key(args.business) || !key(args.project) || (args.snapshot !== undefined && !id(args.snapshot))) refuse('invalid-request');
|
|
const { business, project } = args;
|
|
const builtin = await builtinBinding?.({ business, project });
|
|
if (args.snapshot && builtin?.id === args.snapshot) return structuredClone(builtin);
|
|
const events = journal.snapshotEvents(business, project);
|
|
const snapshot = args.snapshot ?? [...events].reverse().find(e => e.kind === 'activated')?.snapshot;
|
|
if (!snapshot) {
|
|
if (builtin && builtin.origin === 'builtin' && builtin.business === business && builtin.project === project) return builtin;
|
|
refuse('requirement-snapshot-required');
|
|
}
|
|
const snap = journal.snapshot(snapshot);
|
|
if (!snap || snap.business !== business || snap.project !== project) refuse('requirement-snapshot-refused');
|
|
if (eventFor(snap)?.kind !== 'activated') refuse('requirement-snapshot-revoked');
|
|
const spec = await readSpec({ business, project });
|
|
const mode = journal.projectState(business, project);
|
|
if (!spec.confirmed || spec.commit !== snap.spec_commit || mode?.revision !== snap.mode_revision) {
|
|
invalidate(business, project, 'requirement-snapshot-revoked'); refuse('requirement-snapshot-revoked');
|
|
}
|
|
const state = journal.stateForRequest(journal.snapshotRequest(snap.id));
|
|
const binding = state && journal.submission(business, state.request, snap.approval.decision);
|
|
const authority = journal.authority(state, binding);
|
|
if (digest(journal.approval(state, binding)) !== digest(snap.approval)) refuse('prd-authority-refused');
|
|
// Reread immutable records, including selected-path equality at HEAD, before admitting new work.
|
|
const material = await journal.readCandidate(binding.candidate, business);
|
|
if (digest(material.candidate) !== digest(binding.candidate) || digest(material.authors) !== digest(snap.authors) ||
|
|
digest(material.candidate.requirements.map((r, i) => ({ ...r, text: material.requirements[i].text }))) !== digest(snap.requirements)) refuse('prd-candidate-stale');
|
|
if (digest(journal.authority(journal.stateForRequest(state.request), binding)) !== digest(authority) || eventFor(snap)?.kind !== 'activated' || journal.projectState(business, project)?.revision !== snap.mode_revision) refuse('requirement-snapshot-revoked');
|
|
return structuredClone(snap);
|
|
}
|
|
async function activateOnce(args) {
|
|
exact(args, ['request','decision']); if (!id(args.request) || !id(args.decision)) refuse('invalid-request');
|
|
const state = journal.stateForRequest(args.request) ?? refuse('request-not-found');
|
|
const binding = journal.submission(state.business, state.request, args.decision) ?? refuse('prd-candidate-required');
|
|
const old = journal.committed(state.business, 'prd-activate').find(e => e.request === state.request && e.result?.decision === args.decision);
|
|
if (old) return structuredClone(journal.snapshot(old.result.snapshot));
|
|
if (requestArchived(state, { projectArchived, threadProject })) refuse('project-archived');
|
|
if (state.phase !== 'prd-review' || state.wait?.subject !== args.decision || digest(state.candidate) !== digest(binding.candidate)) refuse('prd-admission-revoked');
|
|
const authority = journal.authority(state, binding), approval = journal.approval(state, binding);
|
|
const material = await journal.readCandidate(binding.candidate, state.business);
|
|
if (digest(material.candidate) !== digest(binding.candidate) || digest(material.authors) !== digest(binding.authors)) refuse('prd-candidate-stale');
|
|
const spec = await readSpec({ business: state.business, project: state.project });
|
|
if (!spec.confirmed || spec.commit !== binding.candidate.spec_commit) refuse('stale-spec');
|
|
return journal.transaction(() => {
|
|
const prior = journal.committed(state.business, 'prd-activate').find(e => e.request === state.request && e.result?.decision === args.decision);
|
|
if (prior) return structuredClone(journal.snapshot(prior.result.snapshot));
|
|
if (requestArchived(state, { projectArchived, threadProject })) refuse('project-archived');
|
|
const current = journal.readRequest(state.business, state.request);
|
|
if (current.revision !== state.revision || current.wait?.subject !== args.decision || journal.projectState(state.business, state.project)?.revision !== binding.candidate.mode_revision) refuse('prd-admission-revoked');
|
|
if (digest(journal.authority(current, binding)) !== digest(authority) || digest(journal.approval(current, binding)) !== digest(approval)) refuse('prd-admission-revoked');
|
|
const c = binding.candidate, snapshot = { version: 1, id: `prd-${digest({ business: state.business, candidate: c, decision: args.decision })}`,
|
|
business: state.business, project: state.project, prd_version: c.prd_version, records_commit: c.records_commit, prd_path: c.prd_path,
|
|
prd_blob: c.prd_blob, spec_commit: c.spec_commit, requirements: c.requirements.map((r, i) => ({ ...r, text: material.requirements[i].text })),
|
|
authors: material.authors, approval, mode_revision: c.mode_revision, origin: 'product' };
|
|
const header = { version: 1, business: state.business, request: state.request, op: `prd-activate:${args.decision}`, kind: 'prd-activate', digest: digest(c) };
|
|
journal.prepareEffect({ ...header, stage: 'prepared', result: null, code: null });
|
|
journal.publishSnapshot(snapshot);
|
|
journal.snapshotEvent({ business: state.business, project: state.project, snapshot: snapshot.id, kind: 'activated', cause: args.decision });
|
|
append(current, 'prd.activated', { decision: args.decision, snapshot: snapshot.id });
|
|
journal.finishEffect({ ...header, stage: 'committed', result: { snapshot: snapshot.id, decision: args.decision }, code: null });
|
|
return snapshot;
|
|
});
|
|
}
|
|
function revoke(identity, args) {
|
|
exact(args, ['project','snapshot','revision','reason','op']);
|
|
if (!key(args.project) || !id(args.snapshot) || !Number.isSafeInteger(args.revision) || args.revision < 1 || !text(args.reason, 1024) || !id(args.op)) refuse('invalid-request');
|
|
return journal.transaction(() => {
|
|
const snap = journal.snapshot(args.snapshot);
|
|
if (!snap || snap.business !== identity.business || snap.project !== args.project) refuse('requirement-snapshot-refused');
|
|
const cause = JSON.stringify({ op: args.op, reason: args.reason, by: identity.human, digest: digest(args) });
|
|
const events = journal.snapshotEvents(identity.business, args.project), old = events.find(e => e.kind === 'revoked' && e.cause === cause);
|
|
if (old) return { snapshot: old.snapshot, revision: old.revision, kind: old.kind, cause: old.cause };
|
|
if (events.some(e => { try { return JSON.parse(e.cause).op === args.op; } catch { return false; } })) refuse('request-operation-conflict');
|
|
if ((events.at(-1)?.revision ?? 0) !== args.revision) refuse('request-revision-conflict');
|
|
const result = journal.snapshotEvent({ business: identity.business, project: args.project, snapshot: snap.id, kind: 'revoked', cause });
|
|
for (const row of journal.listRequests()) {
|
|
const state = journal.readRequest(row.business, row.request);
|
|
if (row.business === identity.business && state.project === args.project && !['complete','delivered','cancelled'].includes(state.phase) && state.snapshot === snap.id) append(state, 'prd.invalidated', { code: 'requirement-snapshot-revoked' });
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
const pending = new Map();
|
|
function activate(args) {
|
|
const operation = `${args?.request}/${args?.decision}`;
|
|
if (pending.has(operation)) return pending.get(operation);
|
|
const job = activateOnce(args).finally(() => { if (pending.get(operation) === job) pending.delete(operation); });
|
|
pending.set(operation, job); return job;
|
|
}
|
|
return Object.freeze({ resolve, activate, invalidate, revoke, drain: () => Promise.allSettled([...pending.values()]) });
|
|
}
|