filegrc 0.6.3 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filegrc",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Zero-dependency Git-native GRC engine",
   "license": "MIT",
   "repository": {

package/src/collection-review.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
+import { scopedCollectionRecords } from "./collection-scope.js";
 import { applyResourceBatch } from "./files.js";
 import { getGitSummary } from "./git.js";
 import { loadWorkspace } from "./workspace.js";
-import { programComponents, resolveProgram, selectedRequirementIds } from "./program.js";
+import { resolveProgram, selectedRequirementIds } from "./program.js";
 
 export function collectionRevision(loaded, resourceType, options = {}) {
   const program = resolveProgram(loaded, options.programId);
@@ -200,26 +201,6 @@ export async function applyCollectionReview(input = process.cwd(), options = {})
   };
 }
 
-function scopedCollectionRecords(loaded, resourceType, program) {
-  if (String(loaded.model.modelVersion) !== "4") {
-    return loaded.resources.filter((record) => record.type === resourceType);
-  }
-  const components = programComponents(loaded, program);
-  const componentIds = new Set(components.map(({ id }) => id));
-  const selected = {
-    system: new Set(program.systemIds || []),
-    component: componentIds,
-    framework: new Set(program.frameworkIds || []),
-    vendor: new Set(components.map(({ vendorId }) => vendorId).filter(Boolean)),
-    asset: new Set(loaded.resources.filter((record) => (
-      record.type === "asset" && (record.componentIds || []).some((id) => componentIds.has(id))
-    )).map(({ id }) => id))
-  }[resourceType];
-  return loaded.resources.filter((record) => (
-    record.type === resourceType && (!selected || selected.has(record.id))
-  ));
-}
-
 function requiredType(loaded, value) {
   const resourceType = String(value || "").trim();
   if (!loaded.model.collectionReviews?.[resourceType]) {

package/src/collection-scope.js

@@ -0,0 +1,24 @@
+import { programComponents } from "./program.js";
+
+export function scopedCollectionRecords(loaded, resourceType, program) {
+  if (String(loaded.model.modelVersion) !== "4") {
+    return loaded.resources.filter((record) => record.type === resourceType);
+  }
+  if (resourceType === "vendor") {
+    return loaded.resources.filter((record) => record.type === "vendor");
+  }
+  const scopedProgram = program || {};
+  const components = programComponents(loaded, scopedProgram);
+  const componentIds = new Set(components.map(({ id }) => id));
+  const selected = {
+    system: new Set(scopedProgram.systemIds || []),
+    component: componentIds,
+    framework: new Set(scopedProgram.frameworkIds || []),
+    asset: new Set(loaded.resources.filter((record) => (
+      record.type === "asset" && (record.componentIds || []).some((id) => componentIds.has(id))
+    )).map(({ id }) => id))
+  }[resourceType];
+  return loaded.resources.filter((record) => (
+    record.type === resourceType && (!selected || selected.has(record.id))
+  ));
+}

package/src/validate.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 import { performance } from "node:perf_hooks";
 import { getResourceDefinition } from "../model/index.js";
+import { scopedCollectionRecords } from "./collection-scope.js";
 import { isSafeGitName } from "./git-name.js";
 import { isCanonicalDataPath, resolveDataPath } from "./paths.js";
 import { parseCalendarDate, validCalendarRecurrence } from "./recurrence.js";
@@ -78,7 +79,7 @@ async function validateWorkspaceUnmeasured(input) {
     if (record.type === "control") validateControlComponents(record, byId, displayPath, diagnostics);
     if (record.type === "audit") validateAuditSubservices(record, byId, displayPath, diagnostics);
     if (record.type === "collection-review") {
-      validateCollectionReview(record, loaded.model, loaded.resources, byId, displayPath, diagnostics);
+      validateCollectionReview(record, loaded, byId, displayPath, diagnostics);
     }
     if (record.type === "obligation") validateObligation(record, loaded.model, byId, displayPath, diagnostics);
     if (record.type === "action-item") {
@@ -158,8 +159,9 @@ async function validateWorkspaceUnmeasured(input) {
   };
 }
 
-function validateCollectionReview(record, model, resources, byId, path, diagnostics) {
+function validateCollectionReview(record, loaded, byId, path, diagnostics) {
   if (record.status !== "active") return;
+  const { model } = loaded;
   const configuration = model.collectionReviews?.[record.resourceType];
   if (!configuration) return;
   const allowedDecisions = configuration.decisions || ["complete"];
@@ -174,21 +176,7 @@ function validateCollectionReview(record, model, resources, byId, path, diagnost
   const program = String(model.modelVersion) === "4"
     ? (record.scopeResourceIds || []).map((id) => byId.get(id)).find(({ type } = {}) => type === "program")
     : null;
-  const programSystemIds = new Set(program?.systemIds || []);
-  const componentIds = new Set(resources.filter((candidate) => (
-    candidate.type === "component"
-    && (candidate.systemUses || []).some(({ systemId }) => programSystemIds.has(systemId))
-  )).map(({ id }) => id));
-  const selectedIds = {
-    system: programSystemIds,
-    component: componentIds,
-    framework: new Set(program?.frameworkIds || []),
-    vendor: new Set(resources.filter(({ id }) => componentIds.has(id)).map(({ vendorId }) => vendorId).filter(Boolean)),
-    asset: new Set(resources.filter(({ type, componentIds: ids }) => type === "asset" && (ids || []).some((id) => componentIds.has(id))).map(({ id }) => id))
-  }[record.resourceType];
-  const recordCount = resources.filter(({ type, id }) => (
-    type === record.resourceType && (!program || !selectedIds || selectedIds.has(id))
-  )).length;
+  const recordCount = scopedCollectionRecords(loaded, record.resourceType, program).length;
   if (!recordCount && record.decision === "complete") {
     diagnostics.push(error(
       "invalid-collection-review-decision",