adds detailLevel config

Author: RubenHalman

README.md

@@ -15,6 +15,7 @@
   - [Defining Severity Levels](#defining-severity-levels)
   - [Configuring Expressions](#configuring-expressions)
   - [Specifying Exceptions](#specifying-exceptions)
+  - [Report Detail Level](#report-detail-level)
   - [Include Beta Rules](#include-beta-rules)
 - **[Usage](#Usage)**
   - [Examples](#examples)
@@ -125,7 +126,7 @@ _[UnusedVariable](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tr
 
 ## Configuration
 
-It is recommended to set up configuration and define:
+Lightning Flow Scanner is plug-and-play by default, but we recommend configuring and defining:
 
 - The rules to be executed.
 - The severity of violating any specific rule.
@@ -226,6 +227,22 @@ _Example_
 }
 ```
 
+### Report Detail Level
+
+Control the verbosity of violation reports via detailLevel. By default (`enriched`), outputs include element or flow-level details like variable data types, node connectors/locations, or attribute expressions for comprehensive reports. Set to `simple` for lighter output with only line and column numbers.
+
+```json
+{
+  "rules": {
+    ...
+  },
+  "exceptions": {
+    ...
+  },
+  "detailLevel": "simple"
+}
+```
+
 ### Include Beta Rules
 
 New rules are introduced in Beta mode before being added to the default ruleset. To include current Beta rules, enable the optional betamode parameter in your configuration:
@@ -238,15 +255,16 @@ New rules are introduced in Beta mode before being added to the default ruleset.
   "exceptions": {
     ...
   },
-  "betamode": true
+  "betaMode": true
 }
+
 ```
 
 ---
 
 ## Usage
 
-`lightning-flow-scanner-core` can be used as a dependency in Node.js and browser environments, or as a standalone UMD module.
+Use `lightning-flow-scanner-core` as a Node.js/browser dependency or standalone UMD module.
 
 ### Examples
 

src/main/interfaces/AutoFixable.ts

@@ -1,8 +1,15 @@
 import { IExceptions } from "./IExceptions";
 import { IRuleOptions } from "./IRuleOptions";
 
+export enum DetailLevel {
+  ENRICHED = 'enriched',
+  SIMPLE = 'simple'
+}
+
 export interface IRulesConfig {
-  betamode?: boolean;
+  betaMode?: boolean;  // Toggles beta rules; defaults to false
+  betamode?: boolean;  // Use betaMode instead; to be removed
+  detailLevel?: 'enriched' | 'simple' | DetailLevel;
   exceptions?: IExceptions;
   rules?: IRuleOptions; 
 }

src/main/interfaces/IRulesConfig.ts

@@ -1,3 +1,4 @@
+
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 import { IRulesConfig } from "../interfaces/IRulesConfig";
 import { BetaRuleStore, DefaultRuleStore } from "../store/DefaultRuleStore";
@@ -9,7 +10,7 @@ export function getBetaRules(): IRuleDefinition[] {
 
 export function GetRuleDefinitions(ruleConfig?: Map<string, unknown>, options?: IRulesConfig): IRuleDefinition[] {
   const selectedRules: IRuleDefinition[] = [];
-  const includeBeta = options?.betamode === true;
+  const includeBeta = options?.betaMode === true || options?.betamode === true;
 
   if (ruleConfig && ruleConfig instanceof Map) {
     for (const ruleName of ruleConfig.keys()) {

src/main/libs/GetRuleDefinitions.ts

@@ -5,6 +5,7 @@ import {
   RuleResult,
   ScanResult,
 } from "../../main/internals/internals";
+import { DetailLevel } from "../interfaces/IRulesConfig";
 import { ParsedFlow } from "../models/ParsedFlow";
 import { enrichViolationsWithLineNumbers } from "../models/Violation";
 import { GetRuleDefinitions } from "./GetRuleDefinitions";
@@ -23,7 +24,12 @@ export function scan(parsedFlows: ParsedFlow[], ruleOptions?: IRulesConfig): Sca
 export function ScanFlows(flows: Flow[], ruleOptions?: IRulesConfig): ScanResult[] {
   const flowResults: ScanResult[] = [];
   let selectedRules: IRuleDefinition[] = [];
-
+  const rawMode = ruleOptions?.detailLevel;
+  const detailLevel = 
+    typeof rawMode === 'string' && rawMode.toLowerCase() === 'simple'
+      ? DetailLevel.SIMPLE
+      : DetailLevel.ENRICHED;
+  
   if (ruleOptions?.rules && Object.keys(ruleOptions.rules).length > 0) {
     const ruleMap = new Map<string, object>();
     for (const [ruleName, config] of Object.entries(ruleOptions.rules)) {
@@ -33,38 +39,40 @@ export function ScanFlows(flows: Flow[], ruleOptions?: IRulesConfig): ScanResult
   } else {
     selectedRules = GetRuleDefinitions();
   }
-
-  // Simple cache for flowXml (generated only when needed)
+  
   const flowXmlCache = new Map<string, string>();
-
+  
   for (const flowInput of flows) {
-    // Ensure it's a Flow instance (for tests with mocked JSONs); no-op if already Flow
     const flow = flowInput instanceof Flow ? flowInput : Flow.from(flowInput);
-
     const ruleResults: RuleResult[] = [];
+    
     for (const rule of selectedRules) {
       try {
         if (!rule.supportedTypes.includes(flow.type)) {
           ruleResults.push(new RuleResult(rule, []));
           continue;
         }
+        
         let config: object | undefined = undefined;
         if (ruleOptions?.rules?.[rule.name]) {
           config = ruleOptions.rules[rule.name];
         }
+        
         const rawSuppressions: string[] | undefined =
           ruleOptions?.exceptions?.[flow.name]?.[rule.name];
+        
         const suppressions: string[] =
           rawSuppressions?.includes("*") ? ["*"] : (rawSuppressions ?? []);
+        
         const result =
           config && Object.keys(config).length > 0
             ? rule.execute(flow, config, suppressions)
             : rule.execute(flow, undefined, suppressions);
+        
         if (result.severity !== rule.severity) {
           result.severity = rule.severity as string;
         }
-
-        // Enrich only if violations exist (and cache XML if needed)
+        
         if (result.details.length > 0) {
           let flowXml = flowXmlCache.get(flow.name);
           if (!flowXml) {
@@ -75,20 +83,29 @@ export function ScanFlows(flows: Flow[], ruleOptions?: IRulesConfig): ScanResult
             enrichViolationsWithLineNumbers(result.details, flowXml);
           }
         }
-
+        
         ruleResults.push(result);
       } catch (error) {
         const message = `Something went wrong while executing ${rule.name} in the Flow: ${flow.name} with error ${error}`;
         ruleResults.push(new RuleResult(rule, [], message));
       }
     }
+    
     flowResults.push(new ScanResult(flow, ruleResults));
-
-    // Clear per-flow cache to free memory
     flowXmlCache.delete(flow.name);
   }
-
-  // Clear global cache
+  
   flowXmlCache.clear();
+  
+  if (detailLevel === DetailLevel.SIMPLE) {
+    flowResults.forEach(scanResult => {
+      scanResult.ruleResults.forEach(ruleResult => {
+        ruleResult.details.forEach(violation => {
+          delete violation.details;
+        });
+      });
+    });
+  }
+  
   return flowResults;
 }

src/main/libs/ScanFlows.ts

@@ -21,7 +21,7 @@ describe("Rule Configurations ", () => {
   it.skip("should use default and include beta", async () => {
     const flows = await core.parse([example_uri1]);
     const ruleConfig = {
-      betamode: true,
+      betaMode: true,
       exceptions: {
         CreateANewAccountWithChild: { DuplicateDMLOperation: ["ViewAccountId"] },
       },

tests/ConfigBetaMode.test.ts

@@ -1,16 +1,12 @@
 import * as core from "../src";
 import * as path from "path";
-
 import { parse } from "../src/main/libs/ParseFlows";
 import { ParsedFlow } from "../src/main/models/ParsedFlow";
-
 import { UnconnectedElement } from "../src/main/rules/UnconnectedElement";
-
 import { describe, it, expect } from "@jest/globals";
 
 describe("UnconnectedElement", () => {
   const unconnectedElementRule: UnconnectedElement = new UnconnectedElement();
-
   it("there should be checks for unconnected element", async () => {
     const connectedElementTestFile = path.join(
       __dirname,
@@ -24,7 +20,6 @@ describe("UnconnectedElement", () => {
       expect(detail.name).toBe("unused_assignment");
     });
   });
-
   it("async path there should be checks for unconnected element", async () => {
     const connectedElementTestFile = path.join(
       __dirname,
@@ -37,7 +32,6 @@ describe("UnconnectedElement", () => {
       expect(ruleDetail.name).toBe("UnconnectedElementTestOnAsync");
     });
   });
-
   it("should fix the unconnected element error", async () => {
     const connectedElementTestFile = path.join(
       __dirname,
@@ -58,4 +52,23 @@ describe("UnconnectedElement", () => {
     const fixedResultsOccurring = newResults[0].ruleResults.filter((rule) => rule.occurs);
     expect(fixedResultsOccurring).toHaveLength(0);
   });
-});
+  it("should not include enriched details with detailLevel simple", async () => {
+    const testFile = path.join(
+      __dirname,
+      "../assets/example-flows/force-app/main/default/flows/Unconnected_Element.flow-meta.xml"
+    );
+    const flows = await core.parse([testFile]);
+    const ruleConfig = {
+      detailLevel: "simple",
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const ruleResult = results[0].ruleResults.find((r) => r.ruleName === "UnconnectedElement");
+    expect(ruleResult).toBeDefined();
+    expect(ruleResult.occurs).toBe(true);
+    expect(ruleResult.details).not.toHaveLength(0);
+    ruleResult.details.forEach((detail) => {
+      expect(detail.name).toBe("unused_assignment");
+      expect(detail.details).toBeUndefined();
+    });
+  });
+});