@flow-scanner/lightning-flow-scanner-core 6.4.3 → 6.5.1

package/README.md

@@ -30,6 +30,8 @@
 <p>📌<strong>Tip:</strong> To link directly to a specific rule, use the full GitHub anchor link format. Example:</p>
 <p><em><a href="https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context">https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context</a></em></p>
 
+> Want to code a new rule? → See [How to Write a Rule](docs/write-a-rule.md)
+
 ### Action Calls In Loop(Beta)
 
 _[ActionCallsInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/ActionCallsInLoop.ts)_ - To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilizing a single action call containing a collection variable at the end of the loop.

package/index.d.ts

@@ -1,5 +1,6 @@
 import type { IRuleDefinition } from "./main/interfaces/IRuleDefinition";
 import type { IRulesConfig } from "./main/interfaces/IRulesConfig";
+import type { FlatViolation } from "./main/models/FlatViolation";
 import { Compiler } from "./main/libs/Compiler";
 import { exportDetails } from "./main/libs/exportAsDetails";
 import { exportSarif } from "./main/libs/exportAsSarif";
@@ -19,4 +20,4 @@ import { RuleResult } from "./main/models/RuleResult";
 import { ScanResult } from "./main/models/ScanResult";
 import { Violation } from "./main/models/Violation";
 export { Compiler, exportDetails, exportSarif, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getBetaRules, getRules, parse, ParsedFlow, Violation, RuleResult, scan, ScanResult, };
-export type { IRuleDefinition, IRulesConfig };
+export type { FlatViolation, IRuleDefinition, IRulesConfig };

package/main/internals/internals.d.ts

@@ -1,6 +1,7 @@
 import type { IRuleDefinition } from "../interfaces/IRuleDefinition";
 import type { IRulesConfig } from "../interfaces/IRulesConfig";
 import { Compiler } from "../libs/Compiler";
+import { FlatViolation } from "../models/FlatViolation";
 import { Flow } from "../models/Flow";
 import { FlowAttribute } from "../models/FlowAttribute";
 import { FlowElement } from "../models/FlowElement";
@@ -13,5 +14,5 @@ import { RuleCommon } from "../models/RuleCommon";
 import { RuleResult } from "../models/RuleResult";
 import { ScanResult } from "../models/ScanResult";
 import { Violation } from "../models/Violation";
-export { FlowAttribute, FlowElement, FlowNode, FlowType, FlowVariable, FlowResource, Flow, Compiler, ScanResult, RuleResult, Violation, RuleCommon, ParsedFlow, };
+export { FlatViolation, FlowAttribute, FlowElement, FlowNode, FlowType, FlowVariable, FlowResource, Flow, Compiler, ScanResult, RuleResult, Violation, RuleCommon, ParsedFlow, };
 export type { IRuleDefinition, IRulesConfig };

package/main/internals/internals.js

@@ -12,6 +12,9 @@ _export(exports, {
     get Compiler () {
         return _Compiler.Compiler;
     },
+    get FlatViolation () {
+        return _FlatViolation.FlatViolation;
+    },
     get Flow () {
         return _Flow.Flow;
     },
@@ -50,6 +53,7 @@ _export(exports, {
     }
 });
 const _Compiler = require("../libs/Compiler");
+const _FlatViolation = require("../models/FlatViolation");
 const _Flow = require("../models/Flow");
 const _FlowAttribute = require("../models/FlowAttribute");
 const _FlowElement = require("../models/FlowElement");

package/main/libs/exportAsDetails.d.ts

@@ -1,9 +1,3 @@
+import { FlatViolation } from "../models/FlatViolation";
 import { ScanResult } from "../models/ScanResult";
-import { Violation } from "../models/Violation";
-export interface FlatViolation extends Omit<Violation, 'details'> {
-    flowFile: string;
-    flowName: string;
-    ruleName: string;
-    severity: string;
-}
 export declare function exportDetails(results: ScanResult[], includeDetails?: boolean): FlatViolation[];

package/main/models/FlatViolation.d.ts

@@ -0,0 +1,7 @@
+import { Violation } from "./Violation";
+export interface FlatViolation extends Omit<Violation, 'details'> {
+    flowFile: string;
+    flowName: string;
+    ruleName: string;
+    severity: string;
+}

package/main/models/FlatViolation.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/main/models/LoopRuleCommon.d.ts

@@ -1,10 +1,10 @@
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import { Flow, RuleResult } from "../internals/internals";
+import { Flow, Violation } from "../internals/internals";
 import { RuleCommon } from "./RuleCommon";
 import { RuleInfo } from "./RuleInfo";
 export declare abstract class LoopRuleCommon extends RuleCommon implements IRuleDefinition {
     constructor(info: RuleInfo);
-    execute(flow: Flow, options?: object, suppressions?: string[]): RuleResult;
+    protected check(flow: Flow, _options: object | undefined, suppressions: Set<string>): Violation[];
     protected abstract getStatementTypes(): string[];
     private findLoopElements;
     private findLoopEnd;

package/main/models/LoopRuleCommon.js

@@ -11,16 +11,14 @@ Object.defineProperty(exports, "LoopRuleCommon", {
 const _internals = require("../internals/internals");
 const _RuleCommon = require("./RuleCommon");
 let LoopRuleCommon = class LoopRuleCommon extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            const loopElements = this.findLoopElements(flow);
-            if (!loopElements.length) {
-                return new _internals.RuleResult(this, []);
-            }
-            const statementsInLoops = this.findStatementsInLoops(flow, loopElements);
-            const results = statementsInLoops.filter((det)=>!suppSet.has(det.name)).map((det)=>new _internals.Violation(det));
-            return new _internals.RuleResult(this, results);
-        });
+    check(flow, _options, suppressions) {
+        const loopElements = this.findLoopElements(flow);
+        if (!loopElements.length) {
+            return [];
+        }
+        const statementsInLoops = this.findStatementsInLoops(flow, loopElements);
+        const results = statementsInLoops.filter((det)=>!suppressions.has(det.name)).map((det)=>new _internals.Violation(det));
+        return results;
     }
     findLoopElements(flow) {
         var _flow_elements;

package/main/models/RuleCommon.d.ts

@@ -1,6 +1,6 @@
 import { RuleInfo } from "./RuleInfo";
 import * as core from "../internals/internals";
-export declare class RuleCommon {
+export declare abstract class RuleCommon {
     autoFixable: boolean;
     description: string;
     docRefs: Array<{
@@ -17,5 +17,17 @@ export declare class RuleCommon {
     constructor(info: RuleInfo, optional?: {
         severity?: string;
     });
-    protected executeWithSuppression<T extends any[]>(flow: core.Flow, options: object | undefined, suppressions: string[], executeLogic: (suppSet: Set<string>) => core.RuleResult): core.RuleResult;
+    /**
+     * execute() – automatic suppression
+     */
+    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
+    /**
+     * Rules implement this. They should return *all* violations,
+     * NOT pre-filter suppressed ones (unless they need early-exit performance).
+     */
+    protected abstract check(flow: core.Flow, options: object | undefined, suppressions: Set<string>): core.Violation[];
+    /**
+     * Legacy/manual suppression helper (still available for early exits)
+     */
+    protected isSuppressed(name: string, suppressions: Set<string>): boolean;
 }

package/main/models/RuleCommon.js

@@ -64,12 +64,26 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let RuleCommon = class RuleCommon {
-    executeWithSuppression(flow, options, suppressions, executeLogic) {
+    /**
+   * execute() – automatic suppression
+   */ execute(flow, options, suppressions = []) {
+        // Wildcard suppression disables entire rule
         if (suppressions.includes("*")) {
             return new _internals.RuleResult(this, []);
         }
+        // Convert to Set for fast lookup
         const suppSet = new Set(suppressions);
-        return executeLogic(suppSet);
+        // Raw violations from rule
+        let violations = this.check(flow, options, suppSet);
+        // Automatically filter suppressed violations by their .name
+        violations = violations.filter((v)=>!suppSet.has(v.name));
+        // Wrap into RuleResult
+        return new _internals.RuleResult(this, violations);
+    }
+    /**
+   * Legacy/manual suppression helper (still available for early exits)
+   */ isSuppressed(name, suppressions) {
+        return suppressions.has(name);
     }
     constructor(info, optional){
         _define_property(this, "autoFixable", void 0);

package/main/rules/APIVersion.d.ts

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

package/main/rules/APIVersion.js

@@ -52,31 +52,27 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let APIVersion = class APIVersion extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            let flowAPIVersionNumber = null;
-            if (flow.xmldata.apiVersion) {
-                flowAPIVersionNumber = +flow.xmldata.apiVersion;
-            }
-            const results = [];
-            if (!flowAPIVersionNumber) {
-                const detail = new _internals.Violation(new _internals.FlowAttribute("API Version <49", "apiVersion", "<49"));
-                if (!suppSet.has(detail.name)) {
-                    results.push(detail);
-                }
-                return new _internals.RuleResult(this, results);
-            }
-            if (options === null || options === void 0 ? void 0 : options.expression) {
-                const isValid = new Function(`return ${flowAPIVersionNumber}${options.expression};`)();
-                if (!isValid) {
-                    const detail = new _internals.Violation(new _internals.FlowAttribute(`${flowAPIVersionNumber}`, "apiVersion", options.expression));
-                    if (!suppSet.has(detail.name)) {
-                        results.push(detail);
-                    }
-                }
+    check(flow, options, _suppressions) {
+        let flowAPIVersionNumber = null;
+        if (flow.xmldata.apiVersion) {
+            flowAPIVersionNumber = +flow.xmldata.apiVersion;
+        }
+        // No API version
+        if (!flowAPIVersionNumber) {
+            return [
+                new _internals.Violation(new _internals.FlowAttribute("API Version <49", "apiVersion", "<49"))
+            ];
+        }
+        // Custom logic
+        if (options === null || options === void 0 ? void 0 : options.expression) {
+            const isValid = new Function(`return ${flowAPIVersionNumber}${options.expression};`)();
+            if (!isValid) {
+                return [
+                    new _internals.Violation(new _internals.FlowAttribute(`${flowAPIVersionNumber}`, "apiVersion", options.expression))
+                ];
             }
-            return new _internals.RuleResult(this, results);
-        });
+        }
+        return [];
     }
     constructor(){
         super({

package/main/rules/AutoLayout.d.ts

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

package/main/rules/AutoLayout.js

@@ -52,26 +52,16 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let AutoLayout = class AutoLayout extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            var _CanvasMode_value;
-            if (!flow.processMetadataValues) {
-                return new _internals.RuleResult(this, []);
-            }
-            const CanvasMode = flow.xmldata.processMetadataValues.find((mdv)=>mdv.name === "CanvasMode");
-            const autoLayout = (CanvasMode === null || CanvasMode === void 0 ? void 0 : CanvasMode.value) && typeof CanvasMode.value === "object" && CanvasMode.value.stringValue === "AUTO_LAYOUT_CANVAS";
-            if (autoLayout) {
-                return new _internals.RuleResult(this, []);
-            }
-            var _CanvasMode_value_stringValue;
-            const detail = new _internals.Violation(new _internals.FlowAttribute((_CanvasMode_value_stringValue = CanvasMode === null || CanvasMode === void 0 ? void 0 : (_CanvasMode_value = CanvasMode.value) === null || _CanvasMode_value === void 0 ? void 0 : _CanvasMode_value.stringValue) !== null && _CanvasMode_value_stringValue !== void 0 ? _CanvasMode_value_stringValue : "undefined", "CanvasMode", "!== AUTO_LAYOUT_CANVAS"));
-            if (suppSet.has(detail.name)) {
-                return new _internals.RuleResult(this, []);
-            }
-            return new _internals.RuleResult(this, [
-                detail
-            ]);
-        });
+    check(flow, _options) {
+        var _CanvasMode_value;
+        if (!flow.processMetadataValues) return [];
+        const CanvasMode = flow.xmldata.processMetadataValues.find((mdv)=>mdv.name === "CanvasMode");
+        const autoLayout = (CanvasMode === null || CanvasMode === void 0 ? void 0 : CanvasMode.value) && typeof CanvasMode.value === "object" && CanvasMode.value.stringValue === "AUTO_LAYOUT_CANVAS";
+        if (autoLayout) return [];
+        var _CanvasMode_value_stringValue;
+        return [
+            new _internals.Violation(new _internals.FlowAttribute((_CanvasMode_value_stringValue = CanvasMode === null || CanvasMode === void 0 ? void 0 : (_CanvasMode_value = CanvasMode.value) === null || _CanvasMode_value === void 0 ? void 0 : _CanvasMode_value.stringValue) !== null && _CanvasMode_value_stringValue !== void 0 ? _CanvasMode_value_stringValue : "undefined", "CanvasMode", "!== AUTO_LAYOUT_CANVAS"))
+        ];
     }
     constructor(){
         super({

package/main/rules/CopyAPIName.d.ts

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

package/main/rules/CopyAPIName.js

@@ -52,19 +52,10 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let CopyAPIName = class CopyAPIName 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 copyOfElements = [];
-            for (const element of flowElements){
-                const copyOf = new RegExp("Copy_[0-9]+_of_[A-Za-z0-9]+").test(element.name);
-                if (copyOf && !suppSet.has(element.name)) {
-                    copyOfElements.push(element);
-                }
-            }
-            const results = copyOfElements.map((det)=>new _internals.Violation(det));
-            return new _internals.RuleResult(this, results);
-        });
+    check(flow) {
+        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+        const copyOfElements = flowElements.filter((el)=>/Copy_[0-9]+_of_[A-Za-z0-9]+/.test(el.name));
+        return copyOfElements.map((el)=>new _internals.Violation(el));
     }
     constructor(){
         super({

package/main/rules/CyclomaticComplexity.d.ts

@@ -2,10 +2,10 @@ import * as core from "../internals/internals";
 import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class CyclomaticComplexity extends RuleCommon implements IRuleDefinition {
-    constructor();
     private defaultThreshold;
     private cyclomaticComplexityUnit;
-    execute(flow: core.Flow, options?: {
-        threshold: number;
-    }, suppressions?: string[]): core.RuleResult;
+    constructor();
+    protected check(flow: core.Flow, options: {
+        threshold?: number;
+    } | undefined): core.Violation[];
 }

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.Violation(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.Violation(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.Violation(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[];
 }