filegrc 0.12.4 → 0.13.1

package/src/state.js

@@ -368,15 +368,39 @@ async function createResourceDetailFromLoaded(loaded, type, id, options) {
   const entry = loaded.entries.find(({ record }) => record.type === type && record.id === id);
   if (!entry) return null;
   const relativePath = `data/${entry.relativePath}`;
-  const histories = getWorkspaceHistories(loaded.root, [relativePath], 12, {
-    deadlineAt: options.historyDeadlineAt
-  });
+  const includeHistory = options.includeHistory !== false;
+  const histories = includeHistory
+    ? getWorkspaceHistories(loaded.root, [relativePath], 12, {
+        deadlineAt: options.historyDeadlineAt
+      })
+    : new Map();
   return createStateEntry(loaded, entry, {
     includeDetails: true,
-    history: histories.get(relativePath) ?? []
+    includeHistory,
+    history: includeHistory ? histories.get(relativePath) ?? [] : undefined
+  });
+}
+
+export async function createResourceHistory(input, type, id, options = {}) {
+  if (input?.entries && input?.root) return createResourceHistoryFromLoaded(input, type, id, options);
+  return serializeWorkspaceMutation(input, async (root) => {
+    const validation = await validateWorkspace(root);
+    return createResourceHistoryFromLoaded(validation.loaded, type, id, options);
   });
 }
 
+function createResourceHistoryFromLoaded(loaded, type, id, options) {
+  const entry = loaded.entries.find(({ record }) => record.type === type && record.id === id);
+  if (!entry) return null;
+  const relativePath = `data/${entry.relativePath}`;
+  return {
+    history: getWorkspaceHistories(loaded.root, [relativePath], 12, {
+      deadlineAt: options.historyDeadlineAt
+    }).get(relativePath) ?? [],
+    historyLoaded: true
+  };
+}
+
 async function createStateEntry(loaded, entry, options) {
   const record = structuredClone(entry.record);
   const content = {};
@@ -401,7 +425,8 @@ async function createStateEntry(loaded, entry, options) {
     relativePath: `data/${entry.relativePath}`,
     revision: contentRevision(entry.source),
     content,
-    history: options.includeDetails ? options.history : undefined,
+    history: options.includeDetails && options.includeHistory !== false ? options.history : undefined,
+    historyLoaded: options.includeDetails ? options.includeHistory !== false : false,
     detailsLoaded: options.includeDetails
   };
 }

package/src/validate.js

@@ -30,10 +30,17 @@ import { collectionReviewRevision, historicalCollectionReviewSnapshot } from "./
 import {
   reportingRouteRevision,
   reportingRouteBindingExpectationForValidation,
+  reportingRouteCommitTimestamp,
   reportingRouteEventCommit,
   reportingRouteEventAuthorityIssueAtCommit,
+  reportingRouteExactHistoryEntry,
   reportingRouteFixedEvidence,
-  reportingRouteRecordAtRevision
+  reportingRouteProposalIssues,
+  reportingRouteProposalAssessmentTime,
+  reportingRouteRecordAtRevision,
+  reportingRouteRequirementsForProposal,
+  reportingRouteSupportIssues,
+  recordsAtRevision
 } from "./reporting-route-integrity.js";
 import { validateWorkflowHistoryIntegrity } from "./workflow-history-integrity.js";
 
@@ -61,6 +68,7 @@ const COMPLETION_DATE_FIELDS = [
 const COMPLETION_TIMESTAMP_FIELDS = [
   "completedAt", "endedAt", "closedAt", "provisionedOn", "deprovisionedOn"
 ];
+const DEFERRED_VALIDATION_CONCURRENCY = 16;
 
 export async function validateWorkspace(input = process.cwd()) {
   const timingStarted = performance.now();
@@ -83,6 +91,8 @@ async function validateWorkspaceUnmeasured(input) {
   ]));
   const asOf = currentCalendarDate(loaded.workspace?.timezone || "UTC");
   const obligationsByControl = new Map();
+  const deferredDiagnosticTasks = [];
+  const serialContentDiagnosticTasks = [];
   const reviewRecords = loaded.resources.filter((record) => (
     record.status === "active" && ["retention-schedule-item", "requirement-mapping"].includes(record.type)
   ));
@@ -156,7 +166,11 @@ async function validateWorkspaceUnmeasured(input) {
     validateClassification(record, loaded, displayPath, diagnostics);
     validateCompletionDates(record, displayPath, diagnostics);
     validateReportingRouteBinding(record, loaded, displayPath, diagnostics);
-    await validateAttestationBinding(record, loaded.model, loaded.root, byId, displayPath, diagnostics);
+    serialContentDiagnosticTasks.push(async () => {
+      const deferredDiagnostics = [];
+      await validateAttestationBinding(record, loaded.model, loaded.root, byId, displayPath, deferredDiagnostics);
+      return deferredDiagnostics;
+    });
 
     const fields = { ...loaded.model.commonFields, ...definition.fields };
     for (const [fieldName, field] of Object.entries(fields)) {
@@ -166,16 +180,19 @@ async function validateWorkspaceUnmeasured(input) {
         const values = Array.isArray(value) ? value : [value];
         for (const item of values) {
           if (typeof item !== "string") continue;
-          try {
-            const path = resolveDataPath(loaded.root, item);
-            if (!(await stat(path)).isFile()) throw new Error("The data path is not a file.");
-          } catch {
-            diagnostics.push(error(
-              "missing-content",
-              displayPath,
-              `${fieldName} points to unavailable data path "${item}".`
-            ));
-          }
+          deferredDiagnosticTasks.push(async () => {
+            try {
+              const path = resolveDataPath(loaded.root, item);
+              if (!(await stat(path)).isFile()) throw new Error("The data path is not a file.");
+              return [];
+            } catch {
+              return [error(
+                "missing-content",
+                displayPath,
+                `${fieldName} points to unavailable data path "${item}".`
+              )];
+            }
+          });
         }
       }
       if (field.relation) {
@@ -202,8 +219,19 @@ async function validateWorkspaceUnmeasured(input) {
     validateCompletedObligationEvent(record, byId, loaded.model, displayPath, diagnostics);
     validateActionObligationRule(record, byId, displayPath, diagnostics);
     validateImplementedControlSchedules(record, obligationsByControl, displayPath, diagnostics);
-    await validateMarkdown(record, definition, loaded.model, loaded.root, displayPath, diagnostics);
-    await validateApprovalBinding(record, loaded.model, loaded.root, displayPath, diagnostics);
+    serialContentDiagnosticTasks.push(async () => {
+      const markdownDiagnostics = [];
+      const approvalDiagnostics = [];
+      await validateMarkdown(record, definition, loaded.model, loaded.root, displayPath, markdownDiagnostics);
+      await validateApprovalBinding(record, loaded.model, loaded.root, displayPath, approvalDiagnostics);
+      return [...markdownDiagnostics, ...approvalDiagnostics];
+    });
+  }
+  for (const deferredDiagnostics of await runDeferredValidationTasks(deferredDiagnosticTasks)) {
+    diagnostics.push(...deferredDiagnostics);
+  }
+  for (const task of serialContentDiagnosticTasks) {
+    diagnostics.push(...await task());
   }
   validateRelationshipConstraints(
     loaded.resources,
@@ -278,6 +306,23 @@ async function validateWorkspaceUnmeasured(input) {
   return result;
 }
 
+async function runDeferredValidationTasks(tasks) {
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  const workers = Array.from(
+    { length: Math.min(DEFERRED_VALIDATION_CONCURRENCY, tasks.length) },
+    async () => {
+      while (nextIndex < tasks.length) {
+        const index = nextIndex;
+        nextIndex += 1;
+        results[index] = await tasks[index]();
+      }
+    }
+  );
+  await Promise.all(workers);
+  return results;
+}
+
 function validateDocumentWorkflowScopes(resources, model, byId, pathById, diagnostics) {
   const managementFields = [
     "engagementTermsDocumentId",
@@ -902,6 +947,29 @@ function validateReportingRouteSets(loaded, byId, pathById, diagnostics) {
   }
   for (const route of routeSets) {
     const path = pathById.get(route.id);
+    if (route.status === "proposed") {
+      const proposalHistory = repository.commit
+        ? reportingRouteExactHistoryEntry(loaded, route, repository.commit)
+        : null;
+      const proposalRecords = proposalHistory ? recordsAtRevision(loaded, proposalHistory.commit) : loaded.resources;
+      const proposalRecord = proposalHistory
+        ? proposalRecords.find(({ id }) => id === route.id) || route
+        : route;
+      const proposalAssessmentAt = proposalHistory
+        ? reportingRouteProposalAssessmentTime(proposalHistory.timestamp, new Date())
+        : new Date();
+      if (proposalHistory && !proposalAssessmentAt) {
+        diagnostics.push(error("invalid-reporting-route-proposal-time", path, "The proposal commit time is too far in the future to establish a reliable proposal."));
+      }
+      for (const issue of reportingRouteProposalIssues(proposalRecords, proposalRecord, {
+        at: proposalAssessmentAt || new Date(),
+        timezone: proposalRecords.find(({ type }) => type === "workspace")?.timezone || loaded.workspace?.timezone || "UTC",
+        root: loaded.root,
+        commit: proposalHistory?.commit
+      })) {
+        diagnostics.push(error(issue.code, path, issue.message));
+      }
+    }
     if (["draft", "proposed", "approved"].includes(route.status)) {
       const key = `${route.programId}\0${route.purposeKey}`;
       const current = currentByPurpose.get(key) || { approved: [], pending: [] };
@@ -937,6 +1005,60 @@ function validateReportingRouteSets(loaded, byId, pathById, diagnostics) {
     const proposal = entry ? reportingRouteRecordAtRevision(loaded, entry, route.proposalCommit) : null;
     if (!proposal || proposal.status !== "proposed" || !sameRouteProposal(proposal, route)) {
       diagnostics.push(error("changed-reporting-route-proposal", path, "The approved Route Set facts must exactly match the committed proposal; only managed approval fields may differ."));
+    } else {
+      const proposalRecords = recordsAtRevision(loaded, route.proposalCommit);
+      const proposalTimestamp = reportingRouteCommitTimestamp(loaded, route.id, route.proposalCommit);
+      const proposalAssessmentAt = proposalTimestamp
+        ? reportingRouteProposalAssessmentTime(proposalTimestamp, new Date())
+        : null;
+      if (!proposalTimestamp) {
+        diagnostics.push(error("invalid-reporting-route-proposal", path, "The proposal commit must be an exact Reporting Channel Set history entry."));
+      } else if (!proposalAssessmentAt) {
+        diagnostics.push(error("invalid-reporting-route-proposal-time", path, "The proposal commit time is too far in the future to establish a reliable proposal."));
+      } else {
+        const proposalIssues = reportingRouteProposalIssues(
+          proposalRecords,
+          proposal,
+          {
+            at: proposalAssessmentAt,
+            timezone: proposalRecords.find(({ type }) => type === "workspace")?.timezone || loaded.workspace?.timezone || "UTC",
+            root: loaded.root,
+            commit: route.proposalCommit
+          }
+        );
+        for (const issue of proposalIssues) {
+          diagnostics.push(error(issue.code, path, issue.message));
+        }
+        if (!proposalIssues.length) {
+          const approvalCommit = reportingRouteEventCommit(loaded, route, "approval");
+          const approvalRecords = approvalCommit ? recordsAtRevision(loaded, approvalCommit) : loaded.resources;
+          const liveCommit = route.status === "canceled"
+            ? reportingRouteEventCommit(loaded, route, "cancellation")
+            : null;
+          const liveRecords = liveCommit ? recordsAtRevision(loaded, liveCommit) : loaded.resources;
+          const cutoverAt = route.approval?.effectiveAt || route.approval?.approvedAt || new Date();
+          const cutoverTimezone = route.approval?.timezone || loaded.workspace?.timezone || "UTC";
+          for (const issue of reportingRouteSupportIssues(
+            reportingRouteRequirementsForProposal(approvalRecords, route, {
+              at: cutoverAt,
+              timezone: cutoverTimezone
+            }),
+            route,
+            proposalRecords,
+            liveRecords,
+            {
+              at: cutoverAt,
+              availableAt: route.approval?.approvedAt || new Date(),
+              timezone: cutoverTimezone,
+              root: loaded.root,
+              proposalCommit: route.proposalCommit,
+              currentCommit: liveCommit
+            }
+          )) {
+            diagnostics.push(error(issue.code, path, issue.message));
+          }
+        }
+      }
     }
     for (const markdown of markdownEntries(loaded.model, route)) {
       const currentPath = `data/${markdown.path}`;