implement additional usage check #67

Author: RubenHalman

example-flows/force-app/main/default/flows/No_Missing_Null_Handler.flow-meta.xml

@@ -131,7 +131,7 @@
             <targetReference>Check_object_type</targetReference>
         </connector>
     </start>
-    <status>Draft</status>
+    <status>Active</status>
     <variables>
         <name>errorMessage</name>
         <dataType>String</dataType>

src/main/rules/MissingNullHandler.ts

@@ -24,10 +24,12 @@ export class MissingNullHandler extends AdvancedRule implements core.IRuleDefini
       (node) => node.metaType === "node" && node.subtype === "decisions"
     ) as core.FlowNode[];
     const getOperationsWithoutNullHandler = [];
+
     for (const getElement of getOperationElements) {
       const elementName = getElement.name;
       let nullCheckFound = false;
       let resultReferences: string[] = [];
+
       if (getElement.element["storeOutputAutomatically"]) {
         resultReferences = [elementName];
       } else if (getElement.element["outputReference"]) {
@@ -38,6 +40,17 @@ export class MissingNullHandler extends AdvancedRule implements core.IRuleDefini
           resultReferences.push(assignment.assignToReference);
         }
       }
+
+      // ✅ Skip check if result is never used inside the flow
+      const resultIsUsed = flow.elements.some((el) => {
+        if (el.name === getElement.name) return false;
+        const json = JSON.stringify(el.element);
+        return resultReferences.some((ref) =>
+          json.includes(`"${ref}"`) || json.includes(`"${ref}.`)
+        );
+      });
+      if (!resultIsUsed) continue;
+
       for (const el of decisionElements) {
         let rules = el.element["rules"];
         const isRuleAnArray = Array.isArray(rules);
@@ -57,7 +70,7 @@ export class MissingNullHandler extends AdvancedRule implements core.IRuleDefini
             if (condition.leftValueReference && condition.leftValueReference.length > 0) {
               const valueReference = condition.leftValueReference;
               for (const ref of resultReferences) {
-                referenceFound = ref.includes(valueReference);
+                referenceFound = valueReference.startsWith(ref);
                 if (referenceFound) {
                   break;
                 }
@@ -86,10 +99,12 @@ export class MissingNullHandler extends AdvancedRule implements core.IRuleDefini
           }
         }
       }
+
       if (!nullCheckFound) {
         getOperationsWithoutNullHandler.push(getElement);
       }
     }
+
     const results = [];
     for (const det of getOperationsWithoutNullHandler) {
       results.push(new core.ResultDetails(det));

tests/No_Missing_Null_Handler.test.ts

@@ -3,22 +3,36 @@ import * as path from "path";
 
 import * as core from "../src";
 
-describe("MissingNullHandler ", () => {
+describe("MissingNullHandler", () => {
   const example_uri = path.join(
     __dirname,
-    "../example-flows/force-app/main/default/flows/No_Missing_Null_Handler.flow-meta.flow-meta.xml"
+    "../example-flows/force-app/main/default/flows/No_Missing_Null_Handler.flow-meta.xml"
   );
-  it("should not return a result ", async () => {
+
+  it("should not return a result", async () => {
     const flows = await core.parse([example_uri]);
+    expect(flows.length).toBeGreaterThan(0); // Fail clearly if flow doesn't load
+
+    console.log("Parsed flows:", flows.map(f => ({
+      name: f.name,
+      type: f.type,
+      status: f.status
+    })));
+
     const ruleConfig = {
       rules: {
         MissingNullHandler: {
-          severity: "error",
-        },
-      },
+          severity: "error"
+        }
+      }
     };
+
     const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results[0].ruleResults[0].ruleName).toBe("MissingNullHandler");
-    expect(results[0].ruleResults[0].occurs).toBe(false);
+    console.log("Scan results:", JSON.stringify(results, null, 2));
+
+    expect(results.length).toBeGreaterThan(0); // 🔥 This is your problem now
+    const ruleResult = results[0].ruleResults.find(r => r.ruleName === "MissingNullHandler");
+    expect(ruleResult).toBeDefined();
+    expect(ruleResult.occurs).toBe(false);
   });
-});
+});