@sigloch/contracts 6.0.0 → 6.3.0

package/dist/se/uc-quality-rules.js

@@ -1,10 +1,13 @@
+import { indexOf } from './graph-index.js';
 // ---------------------------------------------------------------------------
 // UC-01: UC must have compose→REQ trace (CR-165: satisfy UC→REQ is invalid per meta-model)
 // ---------------------------------------------------------------------------
 export function uc01HasRequirements(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => !graph.traces.some(t => t.source === uc.id && t.type === 'compose' && graph.elements.some(e => e.id === t.target && e.type === 'REQ')))
+    // CR-SM-264: compose-Kanten je UC aus dem Index. Vorher ein Vollscan ueber alle Traces je UC,
+    // darin ein Vollscan ueber alle Elemente je Treffer — `UC x T x E`.
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
+        .filter(uc => !idx.out(uc.id, 'compose').some(t => idx.typeOf(t.target) === 'REQ'))
         .map(uc => ({
         rule_id: 'UC-01',
         severity: 'error',
@@ -18,14 +21,31 @@ export function uc01HasRequirements(graph) {
 // UC-02: UC FCHAIN must have an ACTOR with io trace
 // ---------------------------------------------------------------------------
 export function uc02HasActor(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => {
-        // Check if any ACTOR has io trace to this UC or to a FCHAIN/FLOW in this UC
-        return !graph.traces.some(t => t.type === 'io' &&
-            graph.elements.some(e => e.id === t.source && e.type === 'ACTOR') &&
-            (t.target === uc.id || graph.traces.some(ct => ct.source === uc.id && ct.type === 'compose' && ct.target === t.target)));
-    })
+    // CR-SM-261: dieselbe Frage, einmal statt je UC neu.
+    //
+    // Die alte Fassung scannte je UC alle Traces, darin je io-Trace alle ELEMENTE (die
+    // ACTOR-Suche) und noch einmal alle Traces (die compose-Suche) — `UC × T × (E + T)`. Das
+    // Profil aus CR-SM-260 hat sie mit 50,8 % des gesamten Regellaufs und einem Wachstum von
+    // n^3,05 gemessen, kubisch statt quadratisch und damit die teuerste Regel des Katalogs.
+    //
+    // Die Umkehrung: erst die Menge der io-Ziele bilden, die von einem ACTOR ausgehen (einmal
+    // ueber Elemente und Traces), dann je UC nur noch Mitgliedschaft pruefen. Dieselbe Aussage,
+    // dieselben Befunde in derselben Reihenfolge — die Iteration ueber `graph.elements` bleibt
+    // die aeussere Schleife.
+    const idx = indexOf(graph);
+    const actorIds = idx.idsOfType('ACTOR');
+    const actorIoTargets = new Set(idx.tracesOfType('io').filter(t => actorIds.has(t.source)).map(t => t.target));
+    const composeTargets = new Map();
+    for (const t of idx.tracesOfType('compose')) {
+        const list = composeTargets.get(t.source);
+        if (list)
+            list.push(t.target);
+        else
+            composeTargets.set(t.source, [t.target]);
+    }
+    return idx.elementsOfType('UC')
+        .filter(uc => !actorIoTargets.has(uc.id) &&
+        !(composeTargets.get(uc.id) ?? []).some(target => actorIoTargets.has(target)))
         .map(uc => ({
         rule_id: 'UC-02',
         severity: 'error',
@@ -39,10 +59,9 @@ export function uc02HasActor(graph) {
 // UC-03: UC must have compose→FCHAIN (scenario)
 // ---------------------------------------------------------------------------
 export function uc03HasScenario(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => !graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'FCHAIN')))
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
+        .filter(uc => !idx.out(uc.id, 'compose').some(t => idx.typeOf(t.target) === 'FCHAIN'))
         .map(uc => ({
         rule_id: 'UC-03',
         severity: 'warning',
@@ -77,10 +96,12 @@ export function uc04GoalDefined(graph) {
 // UC-05: UC should have postcondition REQ (CR-165: compose only, satisfy UC→REQ invalid)
 // ---------------------------------------------------------------------------
 export function uc05HasPostcondition(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => !graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'REQ' && e.kinds?.includes('postcondition'))))
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
+        .filter(uc => !idx.out(uc.id, 'compose').some(t => {
+        const target = idx.byId.get(t.target);
+        return target?.type === 'REQ' && target.kinds?.includes('postcondition');
+    }))
         .map(uc => ({
         rule_id: 'UC-05',
         severity: 'info',
@@ -94,10 +115,12 @@ export function uc05HasPostcondition(graph) {
 // UC-06: UC should have precondition REQ (CR-165: compose only, satisfy UC→REQ invalid)
 // ---------------------------------------------------------------------------
 export function uc06HasPrecondition(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => !graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'REQ' && e.kinds?.includes('precondition'))))
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
+        .filter(uc => !idx.out(uc.id, 'compose').some(t => {
+        const target = idx.byId.get(t.target);
+        return target?.type === 'REQ' && target.kinds?.includes('precondition');
+    }))
         .map(uc => ({
         rule_id: 'UC-06',
         severity: 'info',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/contracts",
-  "version": "6.0.0",
+  "version": "6.3.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",