Files
stack/packages/bus/src/requirement-catalog.mjs

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()]) });
}