@flow-scanner/lightning-flow-scanner-core 6.4.2 → 6.5.0

package/main/rules/CyclomaticComplexity.js

@@ -65,33 +65,25 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let CyclomaticComplexity = class CyclomaticComplexity extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            var _flow_elements, _flow_elements1;
-            const threshold = (options === null || options === void 0 ? void 0 : options.threshold) || this.defaultThreshold;
-            let cyclomaticComplexity = 1;
-            const flowDecisions = flow === null || flow === void 0 ? void 0 : (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "decisions");
-            const flowLoops = flow === null || flow === void 0 ? void 0 : (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : _flow_elements1.filter((node)=>node.subtype === "loops");
-            for (const decision of flowDecisions || []){
-                const rules = decision.element["rules"];
-                if (Array.isArray(rules)) {
-                    cyclomaticComplexity += rules.length + 1;
-                } else {
-                    cyclomaticComplexity += 1;
-                }
-            }
-            var _flowLoops_length;
-            cyclomaticComplexity += (_flowLoops_length = flowLoops === null || flowLoops === void 0 ? void 0 : flowLoops.length) !== null && _flowLoops_length !== void 0 ? _flowLoops_length : 0;
-            this.cyclomaticComplexityUnit = cyclomaticComplexity;
-            const results = [];
-            if (cyclomaticComplexity > threshold) {
-                const detail = new _internals.ResultDetails(new _internals.FlowAttribute(`${cyclomaticComplexity}`, "CyclomaticComplexity", `>${threshold}`));
-                if (!suppSet.has(detail.name)) {
-                    results.push(detail);
-                }
-            }
-            return new _internals.RuleResult(this, results);
-        });
+    check(flow, options) {
+        var _flow_elements, _flow_elements1;
+        const threshold = (options === null || options === void 0 ? void 0 : options.threshold) || this.defaultThreshold;
+        let cyclomaticComplexity = 1;
+        const flowDecisions = flow === null || flow === void 0 ? void 0 : (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "decisions");
+        const flowLoops = flow === null || flow === void 0 ? void 0 : (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : _flow_elements1.filter((node)=>node.subtype === "loops");
+        for (const decision of flowDecisions || []){
+            const rules = decision.element["rules"];
+            cyclomaticComplexity += Array.isArray(rules) ? rules.length + 1 : 1;
+        }
+        var _flowLoops_length;
+        cyclomaticComplexity += (_flowLoops_length = flowLoops === null || flowLoops === void 0 ? void 0 : flowLoops.length) !== null && _flowLoops_length !== void 0 ? _flowLoops_length : 0;
+        this.cyclomaticComplexityUnit = cyclomaticComplexity;
+        if (cyclomaticComplexity > threshold) {
+            return [
+                new _internals.Violation(new _internals.FlowAttribute(`${cyclomaticComplexity}`, "CyclomaticComplexity", `>${threshold}`))
+            ];
+        }
+        return [];
     }
     constructor(){
         super({

package/main/rules/DuplicateDMLOperation.d.ts

@@ -3,7 +3,7 @@ import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class DuplicateDMLOperation extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
-    private flagDML;
+    protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
     private findStart;
+    private flagDML;
 }

package/main/rules/DuplicateDMLOperation.js

@@ -52,64 +52,69 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-            const processedElementIndexes = [];
-            const unconnectedElementIndexes = [];
-            const DuplicateDMLOperations = [];
-            const startingNode = this.findStart(flow);
-            if (startingNode === -1) {
-                return new _internals.RuleResult(this, []);
-            }
-            let dmlFlag = false;
-            let indexesToProcess = [
-                startingNode
-            ];
-            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 = [];
-                            if (element.connectors && element.connectors.length > 0) {
-                                for (const connector of element.connectors){
-                                    if (connector.reference) {
-                                        references.push(connector.reference);
-                                    }
+    check(flow, _options, suppressions) {
+        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+        const processedElementIndexes = [];
+        const unconnectedElementIndexes = [];
+        const DuplicateDMLOperations = [];
+        const startingNode = this.findStart(flow);
+        if (startingNode === -1) {
+            return [];
+        }
+        let dmlFlag = false;
+        let indexesToProcess = [
+            startingNode
+        ];
+        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 = [];
+                        if (element.connectors && element.connectors.length > 0) {
+                            for (const connector of element.connectors){
+                                if (connector.reference) {
+                                    references.push(connector.reference);
                                 }
                             }
-                            dmlFlag = this.flagDML(element, dmlFlag);
-                            if (references.length > 0) {
-                                const elementsByReferences = flowElements.filter((el)=>references.includes(el.name));
-                                for (const nextElement of elementsByReferences){
-                                    const nextIndex = flowElements.findIndex((el)=>nextElement.name === el.name);
-                                    if (nextElement.subtype === "screens") {
-                                        if (dmlFlag && nextElement.element["allowBack"] === "true" && nextElement.element["showFooter"] === "true") {
-                                            if (!suppSet.has(nextElement.name)) {
-                                                DuplicateDMLOperations.push(nextElement);
-                                            }
+                        }
+                        dmlFlag = this.flagDML(element, dmlFlag);
+                        if (references.length > 0) {
+                            const elementsByReferences = flowElements.filter((el)=>references.includes(el.name));
+                            for (const nextElement of elementsByReferences){
+                                const nextIndex = flowElements.findIndex((el)=>nextElement.name === el.name);
+                                if (nextElement.subtype === "screens") {
+                                    if (dmlFlag && nextElement.element["allowBack"] === "true" && nextElement.element["showFooter"] === "true") {
+                                        if (!suppressions.has(nextElement.name)) {
+                                            DuplicateDMLOperations.push(nextElement);
                                         }
                                     }
-                                    if (!processedElementIndexes.includes(nextIndex)) {
-                                        indexesToProcess.push(nextIndex);
-                                    }
+                                }
+                                if (!processedElementIndexes.includes(nextIndex)) {
+                                    indexesToProcess.push(nextIndex);
                                 }
                             }
-                            processedElementIndexes.push(index);
                         }
+                        processedElementIndexes.push(index);
                     }
-                } else {
-                    for (const index of flowElements.keys()){
-                        if (!processedElementIndexes.includes(index)) {
-                            unconnectedElementIndexes.push(index);
-                        }
+                }
+            } else {
+                for (const index of flowElements.keys()){
+                    if (!processedElementIndexes.includes(index)) {
+                        unconnectedElementIndexes.push(index);
                     }
                 }
-            }while (processedElementIndexes.length + unconnectedElementIndexes.length < flowElements.length)
-            const results = DuplicateDMLOperations.map((det)=>new _internals.ResultDetails(det));
-            return new _internals.RuleResult(this, results);
-        });
+            }
+        }while (processedElementIndexes.length + unconnectedElementIndexes.length < flowElements.length)
+        return DuplicateDMLOperations.map((det)=>new _internals.Violation(det));
+    }
+    findStart(flow) {
+        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+        if (flow.startElementReference) {
+            return flowElements.findIndex((n)=>n.name === flow.startElementReference);
+        } else {
+            return flowElements.findIndex((n)=>n.subtype === "start");
+        }
     }
     flagDML(element, dmlFlag) {
         const dmlStatementTypes = [
@@ -125,14 +130,6 @@ let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.Rule
             return dmlFlag;
         }
     }
-    findStart(flow) {
-        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        if (flow.startElementReference) {
-            return flowElements.findIndex((n)=>n.name === flow.startElementReference);
-        } else {
-            return flowElements.findIndex((n)=>n.subtype === "start");
-        }
-    }
     constructor(){
         super({
             name: "DuplicateDMLOperation",

package/main/rules/FlowDescription.d.ts

@@ -3,5 +3,5 @@ import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class FlowDescription extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected check(flow: core.Flow, _options: object | undefined, _suppressions: Set<string>): core.Violation[];
 }

package/main/rules/FlowDescription.js

@@ -52,18 +52,14 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let FlowDescription = class FlowDescription extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            var _flow_xmldata;
-            const missingFlowDescription = !((_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : _flow_xmldata.description);
-            if (!missingFlowDescription || suppSet.has("FlowDescription")) {
-                return new _internals.RuleResult(this, []);
-            }
-            const detail = new _internals.ResultDetails(new _internals.FlowAttribute("undefined", "description", "!==null"));
-            return new _internals.RuleResult(this, [
-                detail
-            ]);
-        });
+    check(flow, _options, _suppressions) {
+        var _flow_xmldata;
+        if ((_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : _flow_xmldata.description) {
+            return [];
+        }
+        return [
+            new _internals.Violation(new _internals.FlowAttribute("undefined", "description", "!==null"))
+        ];
     }
     constructor(){
         super({

package/main/rules/FlowName.d.ts

@@ -3,7 +3,7 @@ import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class FlowName extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow, options?: {
+    protected check(flow: core.Flow, options: {
         expression?: string;
-    }, suppressions?: string[]): core.RuleResult;
+    } | undefined, _suppressions: Set<string>): core.Violation[];
 }

package/main/rules/FlowName.js

@@ -52,23 +52,17 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let FlowName = class FlowName extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            var _options_expression;
-            const rawRegexp = (_options_expression = options === null || options === void 0 ? void 0 : options.expression) !== null && _options_expression !== void 0 ? _options_expression : "[A-Za-z0-9]+_[A-Za-z0-9]+";
-            const flowName = flow.name;
-            const conventionApplied = new RegExp(rawRegexp).test(flowName);
-            if (conventionApplied) {
-                return new _internals.RuleResult(this, []);
-            }
-            const detail = new _internals.ResultDetails(new _internals.FlowAttribute(flowName, "name", rawRegexp));
-            if (suppSet.has(detail.name)) {
-                return new _internals.RuleResult(this, []);
-            }
-            return new _internals.RuleResult(this, [
-                detail
-            ]);
-        });
+    check(flow, options, _suppressions) {
+        var _options_expression;
+        const rawRegexp = (_options_expression = options === null || options === void 0 ? void 0 : options.expression) !== null && _options_expression !== void 0 ? _options_expression : "[A-Za-z0-9]+_[A-Za-z0-9]+";
+        var _flow_name;
+        const flowName = (_flow_name = flow.name) !== null && _flow_name !== void 0 ? _flow_name : "";
+        if (new RegExp(rawRegexp).test(flowName)) {
+            return [];
+        }
+        return [
+            new _internals.Violation(new _internals.FlowAttribute(flowName, "name", rawRegexp))
+        ];
     }
     constructor(){
         super({
@@ -77,7 +71,7 @@ let FlowName = class FlowName extends _RuleCommon.RuleCommon {
             docRefs: [
                 {
                     label: "Naming your Flows is more critical than ever. By Stephen Church",
-                    path: "https://www.linkedin.com/posts/stephen-n-church_naming-your-flows-this-is-more-critical-activity-7099733198175158274-1sPx?utm_source=share&utm_medium=member_desktop"
+                    path: "https://www.linkedin.com/posts/stephen-n-church_naming-your-flows-this-is-more-critical-activity-7099733198175158274-1sPx"
                 }
             ],
             isConfigurable: true,

package/main/rules/GetRecordAllFields.d.ts

@@ -3,5 +3,5 @@ import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class GetRecordAllFields extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected check(flow: core.Flow, _options: object | undefined, _suppressions: Set<string>): core.Violation[];
 }

package/main/rules/GetRecordAllFields.js

@@ -52,27 +52,17 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let GetRecordAllFields = class GetRecordAllFields extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            var _flow_elements;
-            const results = [];
-            const getElementNodes = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((element)=>element.subtype === "recordLookups");
-            if (!getElementNodes || getElementNodes.length === 0) {
-                return new _internals.RuleResult(this, results);
-            }
-            const errorNodes = getElementNodes.filter((element)=>{
-                const getRecordElement = element;
-                const hasQualifiedElementDefinition = typeof getRecordElement.element === "object";
-                if (!hasQualifiedElementDefinition) return false;
-                const concreteChildElement = getRecordElement.element;
-                const storeAllFields = "storeOutputAutomatically" in concreteChildElement && concreteChildElement["storeOutputAutomatically"];
-                const hasQueriedFields = "queriedFields" in concreteChildElement && Array.isArray(concreteChildElement["queriedFields"]) && concreteChildElement["queriedFields"].length > 0;
-                const isViolation = storeAllFields && !hasQueriedFields;
-                return isViolation && !suppSet.has(getRecordElement.name);
-            }).map((element)=>new _internals.ResultDetails(element));
-            results.push(...errorNodes);
-            return new _internals.RuleResult(this, results);
-        });
+    check(flow, _options, _suppressions) {
+        var _flow_elements;
+        var _flow_elements_filter;
+        const lookupNodes = (_flow_elements_filter = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((e)=>e.subtype === "recordLookups")) !== null && _flow_elements_filter !== void 0 ? _flow_elements_filter : [];
+        const violations = lookupNodes.filter((node)=>{
+            const el = node.element;
+            const storeAllFields = typeof el === "object" && "storeOutputAutomatically" in el && el.storeOutputAutomatically;
+            const hasQueriedFields = typeof el === "object" && Array.isArray(el.queriedFields) && el.queriedFields.length > 0;
+            return storeAllFields && !hasQueriedFields;
+        }).map((node)=>new _internals.Violation(node));
+        return violations;
     }
     constructor(){
         super({

package/main/rules/HardcodedId.d.ts

@@ -3,5 +3,5 @@ import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class HardcodedId extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected check(flow: core.Flow, _options: object | undefined, _suppressions: Set<string>): core.Violation[];
 }

package/main/rules/HardcodedId.js

@@ -52,20 +52,9 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            const salesforceIdRegex = /\b[a-zA-Z0-9]{5}0[a-zA-Z0-9]{9}([a-zA-Z0-9]{3})?\b/g;
-            const results = [];
-            for (const node of flow.elements){
-                const nodeString = JSON.stringify(node);
-                if (salesforceIdRegex.test(nodeString)) {
-                    if (!suppSet.has(node.name)) {
-                        results.push(new _internals.ResultDetails(node));
-                    }
-                }
-            }
-            return new _internals.RuleResult(this, results);
-        });
+    check(flow, _options, _suppressions) {
+        const salesforceIdRegex = /\b[a-zA-Z0-9]{5}0[a-zA-Z0-9]{9}(?:[a-zA-Z0-9]{3})?\b/g;
+        return flow.elements.filter((node)=>salesforceIdRegex.test(JSON.stringify(node))).map((node)=>new _internals.Violation(node));
     }
     constructor(){
         super({
@@ -80,7 +69,7 @@ let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
                 },
                 {
                     label: "Don't hard code Record Type IDs in Flow. By Stephen Church.",
-                    path: "https://www.linkedin.com/feed/update/urn:li:activity:6947530300012826624/?updateEntityUrn=urn%3Ali%3Afs_feedUpdate%3A%28V2%2Curn%3Ali%3Aactivity%3A6947530300012826624%29"
+                    path: "https://www.linkedin.com/feed/update/urn:li:activity:6947530300012826624/"
                 }
             ],
             isConfigurable: false,

package/main/rules/HardcodedUrl.d.ts

@@ -1,7 +1,7 @@
-import { Flow, RuleResult } from "../internals/internals";
+import { Flow, Violation } from "../internals/internals";
 import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class HardcodedUrl extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: Flow, options?: object, suppressions?: string[]): RuleResult;
+    protected check(flow: Flow, _options: object | undefined, _suppressions: Set<string>): Violation[];
 }

package/main/rules/HardcodedUrl.js

@@ -11,23 +11,10 @@ Object.defineProperty(exports, "HardcodedUrl", {
 const _internals = require("../internals/internals");
 const _RuleCommon = require("../models/RuleCommon");
 let HardcodedUrl = class HardcodedUrl extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            const results = [];
-            if (!flow.elements || flow.elements.length === 0) {
-                return new _internals.RuleResult(this, results);
-            }
-            const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}force\.com/g;
-            for (const element of flow.elements){
-                const nodeString = JSON.stringify(element);
-                if (urlRegex.test(nodeString)) {
-                    if (!suppSet.has(element.name)) {
-                        results.push(new _internals.ResultDetails(element));
-                    }
-                }
-            }
-            return new _internals.RuleResult(this, results);
-        });
+    check(flow, _options, _suppressions) {
+        if (!flow.elements || flow.elements.length === 0) return [];
+        const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}force\.com/g;
+        return flow.elements.filter((element)=>urlRegex.test(JSON.stringify(element))).map((element)=>new _internals.Violation(element));
     }
     constructor(){
         super({

package/main/rules/InactiveFlow.d.ts

@@ -3,5 +3,5 @@ import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class InactiveFlow extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected check(flow: core.Flow, _options: object | undefined, _suppressions: Set<string>): core.Violation[];
 }

package/main/rules/InactiveFlow.js

@@ -52,16 +52,13 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let InactiveFlow = class InactiveFlow extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            const results = [];
-            if (flow.status !== "Active") {
-                if (!suppSet.has("InactiveFlow")) {
-                    results.push(new _internals.ResultDetails(new _internals.FlowAttribute(flow.status, "status", "!= Active")));
-                }
-            }
-            return new _internals.RuleResult(this, results);
-        });
+    check(flow, _options, _suppressions) {
+        if (flow.status !== "Active") {
+            return [
+                new _internals.Violation(new _internals.FlowAttribute(flow.status, "status", "!= Active"))
+            ];
+        }
+        return [];
     }
     constructor(){
         super({

package/main/rules/MissingFaultPath.d.ts

@@ -5,6 +5,6 @@ export declare class MissingFaultPath extends RuleCommon implements IRuleDefinit
     protected applicableElements: string[];
     constructor();
     private isValidSubtype;
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
     private isPartOfFaultHandlingFlow;
 }

package/main/rules/MissingFaultPath.js

@@ -80,32 +80,30 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
         }
         return true;
     }
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            var _flow_elements;
-            const compiler = new _internals.Compiler();
-            const results = [];
-            const elementsWhereFaultPathIsApplicable = ((_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>{
-                const proxyNode = node;
-                return this.isValidSubtype(proxyNode);
-            })).map((e)=>e.name);
-            const isRecordBeforeSave = flow.start.triggerType === "RecordBeforeSave";
-            const visitCallback = (element)=>{
-                var _element_connectors;
-                if (!(element === null || element === void 0 ? void 0 : (_element_connectors = element.connectors) === null || _element_connectors === void 0 ? void 0 : _element_connectors.find((connector)=>connector.type === "faultConnector")) && elementsWhereFaultPathIsApplicable.includes(element.name)) {
-                    if (isRecordBeforeSave && element.subtype === "recordUpdates") {
-                        return;
-                    }
-                    if (!this.isPartOfFaultHandlingFlow(element, flow)) {
-                        if (!suppSet.has(element.name)) {
-                            results.push(new _internals.ResultDetails(element));
-                        }
+    check(flow, _options, suppressions) {
+        var _flow_elements;
+        const compiler = new _internals.Compiler();
+        const results = [];
+        const elementsWhereFaultPathIsApplicable = ((_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>{
+            const proxyNode = node;
+            return this.isValidSubtype(proxyNode);
+        })).map((e)=>e.name);
+        const isRecordBeforeSave = flow.start.triggerType === "RecordBeforeSave";
+        const visitCallback = (element)=>{
+            var _element_connectors;
+            if (!(element === null || element === void 0 ? void 0 : (_element_connectors = element.connectors) === null || _element_connectors === void 0 ? void 0 : _element_connectors.find((connector)=>connector.type === "faultConnector")) && elementsWhereFaultPathIsApplicable.includes(element.name)) {
+                if (isRecordBeforeSave && element.subtype === "recordUpdates") {
+                    return;
+                }
+                if (!this.isPartOfFaultHandlingFlow(element, flow)) {
+                    if (!suppressions.has(element.name)) {
+                        results.push(new _internals.Violation(element));
                     }
                 }
-            };
-            compiler.traverseFlow(flow, flow.startReference, visitCallback);
-            return new _internals.RuleResult(this, results);
-        });
+            }
+        };
+        compiler.traverseFlow(flow, flow.startReference, visitCallback);
+        return results;
     }
     isPartOfFaultHandlingFlow(element, flow) {
         var _flow_elements;

package/main/rules/MissingNullHandler.d.ts

@@ -3,5 +3,5 @@ import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class MissingNullHandler extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
 }