@flow-scanner/lightning-flow-scanner-core 6.10.5 → 6.11.0

package/main/rules/DuplicateDMLOperation.js

@@ -53,88 +53,50 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.RuleCommon {
     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
+        const graph = flow.graph;
+        const start = flow.startReference;
+        if (!start) return [];
+        const violations = [];
+        const visited = new Set();
+        const stack = [
+            {
+                name: start,
+                seenDML: false
+            }
         ];
-        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 (!suppressions.has(nextElement.name)) {
-                                            DuplicateDMLOperations.push(nextElement);
-                                        }
-                                    }
-                                }
-                                if (!processedElementIndexes.includes(nextIndex)) {
-                                    indexesToProcess.push(nextIndex);
-                                }
-                            }
-                        }
-                        processedElementIndexes.push(index);
-                    }
-                }
-            } else {
-                for (const index of flowElements.keys()){
-                    if (!processedElementIndexes.includes(index)) {
-                        unconnectedElementIndexes.push(index);
-                    }
-                }
+        while(stack.length > 0){
+            const { name, seenDML } = stack.pop();
+            const stateKey = `${name}:${seenDML}`;
+            if (visited.has(stateKey)) continue;
+            visited.add(stateKey);
+            const node = graph.getNode(name);
+            if (!node) continue;
+            let nextSeenDML = seenDML || this.isDML(node);
+            if (nextSeenDML && node.subtype === "screens" && node.element["allowBack"] === "true" && node.element["showFooter"] === "true" && !suppressions.has(node.name)) {
+                violations.push(new _internals.Violation(node));
+            // Note: do NOT return early; multiple violations possible
+            }
+            // Reset DML flag after screen with back disabled
+            if (nextSeenDML && node.subtype === "screens" && node.element["allowBack"] !== "true") {
+                nextSeenDML = false;
+            }
+            for (const next of graph.getNextElements(name)){
+                stack.push({
+                    name: next,
+                    seenDML: nextSeenDML
+                });
             }
-        }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");
         }
+        return violations;
     }
-    flagDML(element, dmlFlag) {
-        const dmlStatementTypes = [
-            "recordDeletes",
-            "recordUpdates",
-            "recordCreates"
-        ];
-        if (dmlStatementTypes.includes(element.subtype)) {
-            return true;
-        } else if (dmlFlag === true && element.subtype === "screens" && element.element["allowBack"] === "true") {
-            return false;
-        } else {
-            return dmlFlag;
-        }
+    isDML(node) {
+        return node.subtype === "recordCreates" || node.subtype === "recordUpdates" || node.subtype === "recordDeletes";
     }
     constructor(){
         super({
             name: "DuplicateDMLOperation",
             label: "Duplicate DML Operation",
-            description: "When the flow executes database changes or actions between two screens, it's important to prevent users from navigating back between screens. Failure to do so may result in duplicate database operations being performed within the flow.",
+            description: "When the flow executes database changes between screens, users must not be allowed to navigate back, or duplicate DML operations may occur.",
             supportedTypes: _internals.FlowType.visualTypes,
             docRefs: []
         });

package/main/rules/MissingFaultPath.d.ts

@@ -6,5 +6,9 @@ export declare class MissingFaultPath extends RuleCommon implements IRuleDefinit
     constructor();
     private isValidSubtype;
     protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
+    /**
+     *  Determine if this is a RecordBeforeSave flow.
+     */
+    private isRecordBeforeSaveFlow;
     private isPartOfFaultHandlingFlow;
 }

package/main/rules/MissingFaultPath.js

@@ -82,14 +82,14 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
         return true;
     }
     check(flow, _options, suppressions) {
-        var _flow_elements;
-        const compiler = new _internals.Compiler();
+        var _flow_graph;
         const results = [];
-        const elementsWhereFaultPathIsApplicable = ((_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>{
+        const elementsWhereFaultPathIsApplicable = flow.elements.filter((node)=>{
             const proxyNode = node;
             return this.isValidSubtype(proxyNode);
-        })).map((e)=>e.name);
-        const isRecordBeforeSave = flow.start.triggerType === "RecordBeforeSave";
+        }).map((e)=>e.name);
+        // Check if this is a RecordBeforeSave flow
+        const isRecordBeforeSave = this.isRecordBeforeSaveFlow(flow);
         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)) {
@@ -104,22 +104,26 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
                 }
             }
         };
-        compiler.traverseFlow(flow, flow.startReference, visitCallback);
+        (_flow_graph = flow.graph) === null || _flow_graph === void 0 ? void 0 : _flow_graph.forEachReachable(visitCallback);
         return results;
     }
-    isPartOfFaultHandlingFlow(element, flow) {
-        var _flow_elements;
-        const flowelements = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((el)=>el instanceof _internals.FlowNode);
-        for (const otherElement of flowelements){
-            if (otherElement !== element) {
-                var _otherElement_connectors;
-                if ((_otherElement_connectors = otherElement.connectors) === null || _otherElement_connectors === void 0 ? void 0 : _otherElement_connectors.find((connector)=>connector.type === "faultConnector" && connector.reference === element.name)) {
-                    return true;
-                }
+    /**
+   *  Determine if this is a RecordBeforeSave flow.
+   */ isRecordBeforeSaveFlow(flow) {
+        var _flow_startNode;
+        if ((_flow_startNode = flow.startNode) === null || _flow_startNode === void 0 ? void 0 : _flow_startNode.element) {
+            var _flow_startNode_element;
+            const triggerType = (_flow_startNode_element = flow.startNode.element) === null || _flow_startNode_element === void 0 ? void 0 : _flow_startNode_element["triggerType"];
+            if (triggerType === "RecordBeforeSave") {
+                return true;
             }
         }
         return false;
     }
+    isPartOfFaultHandlingFlow(element, flow) {
+        var _flow_graph;
+        return ((_flow_graph = flow.graph) === null || _flow_graph === void 0 ? void 0 : _flow_graph.isPartOfFaultHandling(element.name)) || false;
+    }
     constructor(){
         super({
             description: "At times, a flow may fail to execute a configured operation as intended. By default, the flow displays an error message to the user and notifies the admin who created the flow via email. However, you can customize this behavior by incorporating a Fault Path. This rule checks DML operations, actions (Send Email, Quick Actions), and Invocable Apex Actions for proper error handling.",

package/main/rules/MissingFilterRecordTrigger.js

@@ -53,10 +53,10 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let MissingFilterRecordTrigger = class MissingFilterRecordTrigger extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        var _flow_xmldata_start, _flow_xmldata, _flow_xmldata_start1, _flow_xmldata1, _flow_xmldata_start2, _flow_xmldata2;
+        var _flow_xmldata_start, _flow_xmldata;
         const violations = [];
         // Check if this is a record-triggered flow
-        const triggerType = (_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : (_flow_xmldata_start = _flow_xmldata.start) === null || _flow_xmldata_start === void 0 ? void 0 : _flow_xmldata_start.triggerType;
+        const triggerType = this.getStartProperty(flow, 'triggerType');
         // Only check flows with record trigger types
         if (!triggerType || ![
             "RecordAfterSave",
@@ -65,9 +65,9 @@ let MissingFilterRecordTrigger = class MissingFilterRecordTrigger extends _RuleC
             return violations;
         }
         // Check if the flow has filters or entry conditions at the flow level
-        const filters = (_flow_xmldata1 = flow.xmldata) === null || _flow_xmldata1 === void 0 ? void 0 : (_flow_xmldata_start1 = _flow_xmldata1.start) === null || _flow_xmldata_start1 === void 0 ? void 0 : _flow_xmldata_start1.filters;
+        const filters = this.getStartProperty(flow, 'filters');
         const hasFilters = !!filters;
-        const scheduledPaths = (_flow_xmldata2 = flow.xmldata) === null || _flow_xmldata2 === void 0 ? void 0 : (_flow_xmldata_start2 = _flow_xmldata2.start) === null || _flow_xmldata_start2 === void 0 ? void 0 : _flow_xmldata_start2.scheduledPaths;
+        const scheduledPaths = (_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : (_flow_xmldata_start = _flow_xmldata.start) === null || _flow_xmldata_start === void 0 ? void 0 : _flow_xmldata_start.scheduledPaths;
         const hasScheduledPaths = !!scheduledPaths;
         // If no filters or scheduled paths (which have their own conditions), flag as violation
         if (!hasFilters && !hasScheduledPaths) {

package/main/rules/RecordIdAsString.js

@@ -53,10 +53,11 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let RecordIdAsString = class RecordIdAsString extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        var _flow_start, _flow_start1, _flow_elements;
+        var _flow_elements;
         const violations = [];
         // Skip record-triggered flows - they don't support this pattern
-        const isRecordTriggered = ((_flow_start = flow.start) === null || _flow_start === void 0 ? void 0 : _flow_start.triggerType) === "RecordAfterSave" || ((_flow_start1 = flow.start) === null || _flow_start1 === void 0 ? void 0 : _flow_start1.triggerType) === "RecordBeforeSave";
+        const triggerType = this.getStartProperty(flow, 'triggerType');
+        const isRecordTriggered = triggerType === "RecordAfterSave" || triggerType === "RecordBeforeDelete" || triggerType === "RecordBeforeSave";
         if (isRecordTriggered) {
             return violations;
         }

package/main/rules/RecursiveAfterUpdate.js

@@ -66,10 +66,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCommon {
     check(flow, _options, suppressions) {
-        var _flow_start, _flow_start1, _flow_elements, _flow_elements_filter, _flow_elements1;
+        var _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);
+        const triggerType = this.getStartProperty(flow, 'triggerType');
+        const recordTriggerType = this.getStartProperty(flow, 'recordTriggerType');
+        const isAfterSave = triggerType === "RecordAfterSave";
+        const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(recordTriggerType);
         if (!isAfterSave || !isQualifiedTriggerTypes) {
             return results;
         }
@@ -86,7 +88,8 @@ let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCo
             }
         }
         // === 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);
+        const flowObject = this.getStartProperty(flow, 'object');
+        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 && flowObject === 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;
         }

package/main/rules/SameRecordFieldUpdates.js

@@ -66,10 +66,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let SameRecordFieldUpdates = class SameRecordFieldUpdates extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        var _flow_start, _flow_start1, _flow_elements;
+        var _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);
+        const triggerType = this.getStartProperty(flow, 'triggerType');
+        const recordTriggerType = this.getStartProperty(flow, 'recordTriggerType');
+        const isBeforeSaveType = triggerType === "RecordBeforeSave";
+        const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(recordTriggerType);
         if (!isBeforeSaveType || !isQualifiedTriggerTypes) {
             return results;
         }

package/main/rules/TriggerOrder.d.ts

@@ -2,7 +2,6 @@ import * as core from "../internals/internals";
 import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class TriggerOrder extends RuleCommon implements IRuleDefinition {
-    protected qualifiedRecordTriggerTypes: Set<string>;
     constructor();
     protected check(flow: core.Flow, _options: object | undefined, _suppressions: Set<string>): core.Violation[];
 }

package/main/rules/TriggerOrder.js

@@ -10,19 +10,6 @@ Object.defineProperty(exports, "TriggerOrder", {
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
 const _RuleCommon = require("../models/RuleCommon");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -66,7 +53,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        if (!("object" in flow.start)) return [];
+        const startObject = this.getStartProperty(flow, "object");
+        // If there's no `object` on the start node, this is NOT a record-triggered flow
+        if (!startObject) {
+            return [];
+        }
+        // This *is* a record-triggered flow → should have triggerOrder
         if (!flow.triggerOrder) {
             return [
                 new _internals.Violation(new _internals.FlowAttribute("TriggerOrder", "TriggerOrder", "10, 20, 30 ..."))
@@ -78,7 +70,7 @@ let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
         super({
             name: "TriggerOrder",
             label: "Trigger Order",
-            description: "With flow trigger ordering, introduced in Spring '22, admins can now assign a priority value to their flows and guarantee their execution order. This priority value is not an absolute value, so the values need not be sequentially numbered as 1, 2, 3, and so on.",
+            description: "With flow trigger ordering, introduced in Spring '22, admins can now assign a priority " + "value to their flows and guarantee their execution order. This priority value is not an " + "absolute value, so the values need not be sequentially numbered as 1, 2, 3, and so on.",
             supportedTypes: [
                 _internals.FlowType.autolaunchedType
             ],
@@ -90,9 +82,6 @@ let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
             ]
         }, {
             severity: "note"
-        }), _define_property(this, "qualifiedRecordTriggerTypes", new Set([
-            "Create",
-            "Update"
-        ]));
+        });
     }
 };

package/main/rules/UnconnectedElement.d.ts

@@ -4,5 +4,4 @@ import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class UnconnectedElement extends RuleCommon implements IRuleDefinition {
     constructor();
     protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
-    private findStart;
 }

package/main/rules/UnconnectedElement.js

@@ -53,23 +53,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let UnconnectedElement = class UnconnectedElement extends _RuleCommon.RuleCommon {
     check(flow, _options, suppressions) {
-        const connectedElements = new Set();
-        const logConnected = (element)=>{
-            connectedElements.add(element.name);
-        };
+        var _flow_graph;
+        const connectedElements = ((_flow_graph = flow.graph) === null || _flow_graph === void 0 ? void 0 : _flow_graph.getReachableElements()) || new Set();
         const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        const startIndex = this.findStart(flowElements);
-        if (startIndex !== -1) {
-            new _internals.Compiler().traverseFlow(flow, flowElements[startIndex].name, logConnected);
-        }
         const unconnectedElements = flowElements.filter((element)=>!connectedElements.has(element.name) && !suppressions.has(element.name));
         return unconnectedElements.map((det)=>new _internals.Violation(det));
     }
-    findStart(nodes) {
-        return nodes.findIndex((n)=>{
-            return n.subtype === "start";
-        });
-    }
     constructor(){
         super({
             description: "To maintain the efficiency and manageability of your Flow, it's best to avoid including unconnected elements that are not in use.",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flow-scanner/lightning-flow-scanner-core",
   "description": "A lightweight engine for Flow metadata in Node.js, and browser environments. Assess and enhance Salesforce Flow automations for best practices, security, governor limits, and performance issues.",
-  "version": "6.10.5",
+  "version": "6.11.0",
   "main": "index.js",
   "exports": {
     ".": {
@@ -22,7 +22,7 @@
   "dependencies": {
     "fast-xml-parser": "^5.3.0"
   },
-  "homepage": "https://dev.lightningflowscanner.org",
+  "homepage": "https://flow-scanner.github.io/lightning-flow-scanner/",
   "author": {
     "name": "Ruben Halman",
     "url": "https://github.com/RubenHalman"