Error Handling Improvements

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightning-flow-scanner-core",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "main": "out/**",
   "types": "index.d.ts",
   "scripts": {

src/main/libs/ScanFlows.ts

@@ -1,8 +1,10 @@
-import { GetRuleDefinitions } from './GetRuleDefinitions';
-import * as core from '../../main/internals/internals';
-
-export function ScanFlows(flows: core.Flow[], ruleOptions?: core.IRulesConfig): core.ScanResult[] {
+import { GetRuleDefinitions } from "./GetRuleDefinitions";
+import * as core from "../../main/internals/internals";
 
+export function ScanFlows(
+  flows: core.Flow[],
+  ruleOptions?: core.IRulesConfig
+): core.ScanResult[] {
   const flowResults: core.ScanResult[] = [];
 
   let selectedRules: core.IRuleDefinition[] = [];
@@ -17,34 +19,39 @@ export function ScanFlows(flows: core.Flow[], ruleOptions?: core.IRulesConfig):
   }
 
   for (const flow of flows) {
-
-    try {
-      const ruleResults: core.RuleResult[] = [];
-      for (const rule of selectedRules) {
+    const ruleResults: core.RuleResult[] = [];
+    for (const rule of selectedRules) {
+      try {
         if (rule.supportedTypes.includes(flow.type[0])) {
-          try {
-            let config = undefined;
-
-            if (ruleOptions && ruleOptions['rules'] && ruleOptions['rules'][rule.name]) {
-              config = ruleOptions['rules'][rule.name];
-            }
-            const result = (config && Object.keys(config).length > 0) ? rule.execute(flow, config) : rule.execute(flow);
-            if (result.severity !== rule.severity) {
-              result.severity = rule.severity;
-            }
-            ruleResults.push(result);
-          } catch (error) {
-            throw new error("Something went wrong while executing " + rule.name + " in the Flow: '" + flow.name + "'");
+          let config = undefined;
+          if (
+            ruleOptions &&
+            ruleOptions["rules"] &&
+            ruleOptions["rules"][rule.name]
+          ) {
+            config = ruleOptions["rules"][rule.name];
           }
+          const result =
+            config && Object.keys(config).length > 0
+              ? rule.execute(flow, config)
+              : rule.execute(flow);
+          if (result.severity !== rule.severity) {
+            result.severity = rule.severity;
+          }
+          ruleResults.push(result);
         } else {
           ruleResults.push(new core.RuleResult(rule, []));
         }
+      } catch (error) {
+        let message =
+          "Something went wrong while executing " +
+          rule.name +
+          " in the Flow: '" +
+          flow.name;
+        ruleResults.push(new core.RuleResult(rule, [], message));
       }
-      flowResults.push(new core.ScanResult(flow, ruleResults));
-    }
-    catch (error) {
-      console.log(error.message)
     }
+    flowResults.push(new core.ScanResult(flow, ruleResults));
   }
 
   return flowResults;

src/main/models/RuleResult.ts

@@ -8,8 +8,9 @@ export class RuleResult {
   public ruleDefinition: IRuleDefinition;
   public severity: string;
   public details: ResultDetails[] = [];
+  public errorMessage: string;
 
-  constructor(info: IRuleDefinition, details: ResultDetails[]) {
+  constructor(info: IRuleDefinition, details: ResultDetails[], errorMessage?:string) {
     this.ruleDefinition = info;
     this.ruleName = info.name;
     this.severity = info.severity ? info.severity : 'error';
@@ -18,6 +19,9 @@ export class RuleResult {
     if(details.length > 0){
       this.occurs = true;
     }
+    if(errorMessage){
+      this.errorMessage = errorMessage;
+    }
   }
 
 }

src/main/rules/UnconnectedElement.ts

@@ -17,75 +17,35 @@ export class UnconnectedElement extends RuleCommon implements core.IRuleDefiniti
 
   public execute(flow: core.Flow): core.RuleResult {
 
+    const connectedElements: Set<string> = new Set<string>();
+
+    // Callback function to log connected elements
+    const logConnected = (element: core.FlowNode) => {
+      connectedElements.add(element.name);
+    };
+
+    // Get Traversable Nodes
     const flowElements: core.FlowNode[] = flow.elements.filter(node => node instanceof core.FlowNode) as core.FlowNode[];
-    let indexesToProcess = [this.findStart(flowElements)];
-    const processedElementIndexes: number[] = [];
-    const unconnectedElementIndexes: number[] = [];
-    if (indexesToProcess[0] && indexesToProcess[0] === -1 && !flow.startElementReference) {
-      throw 'Can not find starting element';
-    }
-    if (indexesToProcess[0] && indexesToProcess[0] === -1 && flow.startElementReference) {
-      indexesToProcess = [
-        flowElements.findIndex(n => {
-          return n.name == flow.startElementReference[0];
-        })
-      ];
-    }
-    do {
-      indexesToProcess = indexesToProcess.filter(index => !processedElementIndexes.includes(index));
-      if (indexesToProcess.length > 0) {
-        for (const [index, element] of flowElements.entries()) {
-          if (indexesToProcess.includes(index)) {
-            const references: string[] = [];
-            if (element.connectors && element.connectors.length > 0) {
-              for (const connector of element.connectors) {
-                if (connector.reference) {
-                  references.push(connector.reference);
-                }
-              }
-            }
-            if (references.length > 0) {
-              const elementsByReferences = flowElements.filter(anElement => references.includes(anElement.name));
-              for (const nextElement of elementsByReferences) {
-                const nextIndex = flowElements.findIndex(anElement => nextElement.name === anElement.name);
-                if (!processedElementIndexes.includes(nextIndex)) {
-                  indexesToProcess.push(nextIndex);
-                }
-              }
-            }
-            processedElementIndexes.push(index);
-          }
-        }
-      } else {
-        for (const index of flowElements.keys()) {
-          if (!processedElementIndexes.includes(index)) {
-            unconnectedElementIndexes.push(index);
-          }
-        }
-      }
-    } while ((processedElementIndexes.length + unconnectedElementIndexes.length) < flowElements.length);
 
-    const processedElements = [];
-    const unconnectedElements = [];
-    for (const [index, element] of flowElements.entries()) {
-      if (processedElementIndexes.includes(index)) {
-        processedElements.push(element);
-      } else if (unconnectedElementIndexes.includes(index)) {
-        unconnectedElements.push(element);
-      }
-    }
-    let results = [];
-    for (const det of unconnectedElements) {
-      results.push(new core.ResultDetails(det));
+    // Find start of Flow
+    const startIndex = this.findStart(flowElements);
+
+    // Start traversal from the start node
+    if (startIndex !== -1) {
+      new core.Compiler().traverseFlow(flow, flowElements[startIndex].name, logConnected);
     }
+
+    const unconnectedElements: core.FlowNode[] = flowElements.filter(element => !connectedElements.has(element.name));
+
+    // Create result details
+    const results = unconnectedElements.map(det => new core.ResultDetails(det));
+
     return new core.RuleResult(this, results);
   }
 
-  private findStart(nodes: core.FlowElement[]) {
+  private findStart(nodes: core.FlowNode[]) {
     return nodes.findIndex(n => {
       return n.subtype === 'start';
     });
   }
-
-
 }

tests/Config.test.ts

@@ -3,6 +3,7 @@ import 'mocha';
 import * as core from '../src'
 import unconnectedElement from './testfiles/UnconnectedElement.json';
 import Hidenav from './testfiles/hidenav.json';
+import flawed from './testfiles/flawedflow.json';
 
 describe('Rule Configurations ', () => {
 
@@ -17,6 +18,16 @@ describe('Rule Configurations ', () => {
     const rules = core.getRules();
     expect(results[0].ruleResults.length).to.equal(rules.length);
   });
+
+  it(' should return errormessage when file seems corrupt', () => {
+    flow2 = new core.Flow({
+      path: './testfiles/flawed.flow-meta.xml',
+      xmldata: flawed,
+    });
+    const results: core.ScanResult[] = core.scan([flow2], undefined);
+    expect(results[0].ruleResults[0].errorMessage);
+  });
+
 
   it(' should use default when no rules are specified', () => {
     flow2 = new core.Flow({

tests/testfiles/flawedflow.json

@@ -0,0 +1,7 @@
+{
+    "Flow": {
+        "$": {
+            "xmlns": "http://soap.sforce.com/2006/04/metadata"
+        }
+    }
+}