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

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

package/main/rules/MissingNullHandler.js

@@ -52,84 +52,81 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let MissingNullHandler = class MissingNullHandler extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            const getOperations = [
-                "recordLookups"
-            ];
-            const getOperationElements = flow.elements.filter((node)=>node.metaType === "node" && getOperations.includes(node.subtype));
-            const decisionElements = flow.elements.filter((node)=>node.metaType === "node" && node.subtype === "decisions");
-            const violations = [];
-            for (const getElement of getOperationElements){
-                var _getElement_connectors;
-                if (suppSet.has(getElement.name)) continue;
-                const elementName = getElement.name;
-                const assignNulls = String(getElement.element["assignNullValuesIfNoRecordsFound"]).toLowerCase() === "true";
-                if (!assignNulls) continue;
-                const hasFaultConnector = !!getElement.element["faultConnector"] || ((_getElement_connectors = getElement.connectors) === null || _getElement_connectors === void 0 ? void 0 : _getElement_connectors.some((c)=>c.type === "faultConnector"));
-                if (hasFaultConnector) continue;
-                const resultReferences = [];
-                if (getElement.element["storeOutputAutomatically"]) {
-                    resultReferences.push(elementName);
-                } else if (getElement.element["outputReference"]) {
-                    resultReferences.push(getElement.element["outputReference"]);
-                } else if (getElement.element["outputAssignments"]) {
-                    const assignments = getElement.element["outputAssignments"];
-                    for (const a of assignments){
-                        resultReferences.push(a.assignToReference);
-                    }
+    check(flow, _options, suppressions) {
+        const getOperations = [
+            "recordLookups"
+        ];
+        const getOperationElements = flow.elements.filter((node)=>node.metaType === "node" && getOperations.includes(node.subtype));
+        const decisionElements = flow.elements.filter((node)=>node.metaType === "node" && node.subtype === "decisions");
+        const violations = [];
+        for (const getElement of getOperationElements){
+            var _getElement_connectors;
+            if (suppressions.has(getElement.name)) continue;
+            const elementName = getElement.name;
+            const assignNulls = String(getElement.element["assignNullValuesIfNoRecordsFound"]).toLowerCase() === "true";
+            if (!assignNulls) continue;
+            const hasFaultConnector = !!getElement.element["faultConnector"] || ((_getElement_connectors = getElement.connectors) === null || _getElement_connectors === void 0 ? void 0 : _getElement_connectors.some((c)=>c.type === "faultConnector"));
+            if (hasFaultConnector) continue;
+            const resultReferences = [];
+            if (getElement.element["storeOutputAutomatically"]) {
+                resultReferences.push(elementName);
+            } else if (getElement.element["outputReference"]) {
+                resultReferences.push(getElement.element["outputReference"]);
+            } else if (getElement.element["outputAssignments"]) {
+                const assignments = getElement.element["outputAssignments"];
+                for (const a of assignments){
+                    resultReferences.push(a.assignToReference);
                 }
-                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;
-                let nullCheckFound = false;
-                for (const decision of decisionElements){
-                    let rules = decision.element["rules"];
-                    if (!Array.isArray(rules)) rules = [
-                        rules
+            }
+            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;
+            let nullCheckFound = false;
+            for (const decision of decisionElements){
+                let rules = decision.element["rules"];
+                if (!Array.isArray(rules)) rules = [
+                    rules
+                ];
+                for (const rule of rules){
+                    let conditions = rule.conditions;
+                    if (!Array.isArray(conditions)) conditions = [
+                        conditions
                     ];
-                    for (const rule of rules){
-                        let conditions = rule.conditions;
-                        if (!Array.isArray(conditions)) conditions = [
-                            conditions
-                        ];
-                        for (const condition of conditions){
-                            var _condition_rightValue;
-                            let referenceFound = false;
-                            let isNullOperator = false;
-                            let checksFalse = false;
-                            if (condition.leftValueReference) {
-                                const ref = condition.leftValueReference;
-                                if (resultReferences.some((r)=>ref.startsWith(r))) {
-                                    referenceFound = true;
-                                }
-                            }
-                            if (condition.operator === "IsNull") {
-                                isNullOperator = true;
-                            }
-                            const rightBool = (_condition_rightValue = condition.rightValue) === null || _condition_rightValue === void 0 ? void 0 : _condition_rightValue.booleanValue;
-                            if (rightBool != null && String(rightBool).toLowerCase() === "false") {
-                                checksFalse = true;
-                            }
-                            if (referenceFound && isNullOperator && checksFalse) {
-                                nullCheckFound = true;
-                                break;
+                    for (const condition of conditions){
+                        var _condition_rightValue;
+                        let referenceFound = false;
+                        let isNullOperator = false;
+                        let checksFalse = false;
+                        if (condition.leftValueReference) {
+                            const ref = condition.leftValueReference;
+                            if (resultReferences.some((r)=>ref.startsWith(r))) {
+                                referenceFound = true;
                             }
                         }
-                        if (nullCheckFound) break;
+                        if (condition.operator === "IsNull") {
+                            isNullOperator = true;
+                        }
+                        const rightBool = (_condition_rightValue = condition.rightValue) === null || _condition_rightValue === void 0 ? void 0 : _condition_rightValue.booleanValue;
+                        if (rightBool != null && String(rightBool).toLowerCase() === "false") {
+                            checksFalse = true;
+                        }
+                        if (referenceFound && isNullOperator && checksFalse) {
+                            nullCheckFound = true;
+                            break;
+                        }
                     }
                     if (nullCheckFound) break;
                 }
-                if (!nullCheckFound) {
-                    violations.push(getElement);
-                }
+                if (nullCheckFound) break;
             }
-            const results = violations.map((det)=>new _internals.Violation(det));
-            return new _internals.RuleResult(this, results);
-        });
+            if (!nullCheckFound) {
+                violations.push(getElement);
+            }
+        }
+        return violations.map((det)=>new _internals.Violation(det));
     }
     constructor(){
         super({

package/main/rules/ProcessBuilder.d.ts

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

package/main/rules/ProcessBuilder.js

@@ -52,14 +52,10 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let ProcessBuilder = class ProcessBuilder extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        const suppSet = new Set(suppressions);
-        if (suppSet.has("ProcessBuilder")) {
-            return new _internals.RuleResult(this, []);
-        }
-        return new _internals.RuleResult(this, [
+    check(flow, _options, _suppressions) {
+        return [
             new _internals.Violation(new _internals.FlowAttribute("Workflow", "processType", "== Workflow"))
-        ]);
+        ];
     }
     constructor(){
         super({

package/main/rules/RecursiveAfterUpdate.d.ts

@@ -4,5 +4,5 @@ import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class RecursiveAfterUpdate extends RuleCommon implements IRuleDefinition {
     protected qualifiedRecordTriggerTypes: Set<string>;
     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/RecursiveAfterUpdate.js

@@ -65,41 +65,39 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            var _flow_start, _flow_start1, _flow_elements, _flow_elements_filter, _flow_elements1;
-            const results = [];
-            const isAfterSave = ((_flow_start = flow.start) === null || _flow_start === void 0 ? void 0 : _flow_start.triggerType) === "RecordAfterSave";
-            const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has((_flow_start1 = flow.start) === null || _flow_start1 === void 0 ? void 0 : _flow_start1.recordTriggerType);
-            if (!isAfterSave || !isQualifiedTriggerTypes) {
-                return new _internals.RuleResult(this, results);
-            }
-            const potentialElements = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "recordUpdates");
-            if (potentialElements == null || typeof potentialElements[Symbol.iterator] !== "function") {
-                return new _internals.RuleResult(this, results);
-            }
-            // === $Record updates ===
-            for (const node of potentialElements){
-                if (typeof node.element === "object" && "inputReference" in node.element && node.element.inputReference === "$Record") {
-                    if (!suppSet.has(node.name)) {
-                        results.push(new _internals.Violation(node));
-                    }
+    check(flow, _options, suppressions) {
+        var _flow_start, _flow_start1, _flow_elements, _flow_elements_filter, _flow_elements1;
+        const results = [];
+        const isAfterSave = ((_flow_start = flow.start) === null || _flow_start === void 0 ? void 0 : _flow_start.triggerType) === "RecordAfterSave";
+        const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has((_flow_start1 = flow.start) === null || _flow_start1 === void 0 ? void 0 : _flow_start1.recordTriggerType);
+        if (!isAfterSave || !isQualifiedTriggerTypes) {
+            return results;
+        }
+        const potentialElements = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "recordUpdates");
+        if (potentialElements == null || typeof potentialElements[Symbol.iterator] !== "function") {
+            return results;
+        }
+        // === $Record updates ===
+        for (const node of potentialElements){
+            if (typeof node.element === "object" && "inputReference" in node.element && node.element.inputReference === "$Record") {
+                if (!suppressions.has(node.name)) {
+                    results.push(new _internals.Violation(node));
                 }
             }
-            // === Lookup → same object type updates ===
-            const lookupElementsWithTheSameObjectType = (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : (_flow_elements_filter = _flow_elements1.filter((node)=>node.subtype === "recordLookups" && typeof node.element === "object" && "object" in node.element && flow.start.object === node.element["object"])) === null || _flow_elements_filter === void 0 ? void 0 : _flow_elements_filter.map((node)=>node.name);
-            if (lookupElementsWithTheSameObjectType == null || typeof lookupElementsWithTheSameObjectType[Symbol.iterator] !== "function") {
-                return new _internals.RuleResult(this, results);
-            }
-            for (const node of potentialElements){
-                if (typeof node.element === "object" && "inputReference" in node.element && lookupElementsWithTheSameObjectType.includes(node.element.inputReference)) {
-                    if (!suppSet.has(node.name)) {
-                        results.push(new _internals.Violation(node));
-                    }
+        }
+        // === Lookup → same object type updates ===
+        const lookupElementsWithTheSameObjectType = (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : (_flow_elements_filter = _flow_elements1.filter((node)=>node.subtype === "recordLookups" && typeof node.element === "object" && "object" in node.element && flow.start.object === node.element["object"])) === null || _flow_elements_filter === void 0 ? void 0 : _flow_elements_filter.map((node)=>node.name);
+        if (lookupElementsWithTheSameObjectType == null || typeof lookupElementsWithTheSameObjectType[Symbol.iterator] !== "function") {
+            return results;
+        }
+        for (const node of potentialElements){
+            if (typeof node.element === "object" && "inputReference" in node.element && lookupElementsWithTheSameObjectType.includes(node.element.inputReference)) {
+                if (!suppressions.has(node.name)) {
+                    results.push(new _internals.Violation(node));
                 }
             }
-            return new _internals.RuleResult(this, results);
-        });
+        }
+        return results;
     }
     constructor(){
         super({

package/main/rules/SameRecordFieldUpdates.d.ts

@@ -4,5 +4,5 @@ import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class SameRecordFieldUpdates extends RuleCommon implements IRuleDefinition {
     protected qualifiedRecordTriggerTypes: Set<string>;
     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/SameRecordFieldUpdates.js

@@ -65,28 +65,22 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 let SameRecordFieldUpdates = class SameRecordFieldUpdates extends _RuleCommon.RuleCommon {
-    execute(flow, options, suppressions = []) {
-        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
-            var _flow_start, _flow_start1, _flow_elements;
-            const results = [];
-            const isBeforeSaveType = ((_flow_start = flow.start) === null || _flow_start === void 0 ? void 0 : _flow_start.triggerType) === "RecordBeforeSave";
-            const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has((_flow_start1 = flow.start) === null || _flow_start1 === void 0 ? void 0 : _flow_start1.recordTriggerType);
-            if (!isBeforeSaveType || !isQualifiedTriggerTypes) {
-                return new _internals.RuleResult(this, results);
-            }
-            const potentialElements = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "recordUpdates");
-            if (potentialElements == null || typeof potentialElements[Symbol.iterator] !== "function") {
-                return new _internals.RuleResult(this, results);
-            }
-            for (const node of potentialElements){
-                if (typeof node.element === "object" && "inputReference" in node.element && node.element.inputReference === "$Record") {
-                    if (!suppSet.has(node.name)) {
-                        results.push(new _internals.Violation(node));
-                    }
-                }
+    check(flow, _options, _suppressions) {
+        var _flow_start, _flow_start1, _flow_elements;
+        const results = [];
+        const isBeforeSaveType = ((_flow_start = flow.start) === null || _flow_start === void 0 ? void 0 : _flow_start.triggerType) === "RecordBeforeSave";
+        const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has((_flow_start1 = flow.start) === null || _flow_start1 === void 0 ? void 0 : _flow_start1.recordTriggerType);
+        if (!isBeforeSaveType || !isQualifiedTriggerTypes) {
+            return results;
+        }
+        const potentialElements = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "recordUpdates");
+        if (!potentialElements) return results;
+        for (const node of potentialElements){
+            if (typeof node.element === "object" && "inputReference" in node.element && node.element.inputReference === "$Record") {
+                results.push(new _internals.Violation(node));
             }
-            return new _internals.RuleResult(this, results);
-        });
+        }
+        return results;
     }
     constructor(){
         super({