@flow-scanner/lightning-flow-scanner-core 6.0.3

package/main/rules/RecursiveAfterUpdate.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RecursiveAfterUpdate", {
+    enumerable: true,
+    get: function() {
+        return RecursiveAfterUpdate;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _AdvancedRule = require("../models/AdvancedRule");
+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();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        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);
+        }
+        for (const node of potentialElements){
+            if (typeof node.element === "object" && "inputReference" in node.element && node.element.inputReference === "$Record") {
+                results.push(new _internals.ResultDetails(node));
+            }
+        }
+        // do another search for record updates from lookups with the same object type
+        // and check whether there is references on record 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)=>{
+            return 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)) {
+                results.push(new _internals.ResultDetails(node));
+            }
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "After updates are meant to be used for record modifications that are not the same record that triggered the flow. Using after updates on the same record can lead to recursion and unexpected behavior. Consider using before save flows for same record updates.",
+            docRefs: [
+                {
+                    label: "Learn about same record field updates",
+                    path: "https://architect.salesforce.com/decision-guides/trigger-automation#Same_Record_Field_Updates"
+                }
+            ],
+            isConfigurable: false,
+            label: "Recursive After Update",
+            name: "RecursiveAfterUpdate",
+            supportedTypes: [
+                ..._internals.FlowType.backEndTypes
+            ]
+        }, {
+            severity: "warning"
+        }), _define_property(this, "qualifiedRecordTriggerTypes", new Set([
+            "Create",
+            "CreateAndUpdate",
+            "Update"
+        ]));
+    }
+};

package/main/rules/SOQLQueryInLoop.d.ts

@@ -0,0 +1,6 @@
+import { IRuleDefinition } from "../internals/internals";
+import { LoopRuleCommon } from "../models/LoopRuleCommon";
+export declare class SOQLQueryInLoop extends LoopRuleCommon implements IRuleDefinition {
+    constructor();
+    protected getStatementTypes(): string[];
+}

package/main/rules/SOQLQueryInLoop.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SOQLQueryInLoop", {
+    enumerable: true,
+    get: function() {
+        return SOQLQueryInLoop;
+    }
+});
+const _internals = require("../internals/internals");
+const _LoopRuleCommon = require("../models/LoopRuleCommon");
+let SOQLQueryInLoop = class SOQLQueryInLoop extends _LoopRuleCommon.LoopRuleCommon {
+    getStatementTypes() {
+        return [
+            "recordLookups"
+        ];
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "To prevent exceeding Apex governor limits, it is advisable to consolidate all your SOQL queries at the conclusion of the flow.",
+            docRefs: [
+                {
+                    label: "Flow Best Practices",
+                    path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5"
+                }
+            ],
+            isConfigurable: false,
+            label: "SOQL Query In A Loop",
+            name: "SOQLQueryInLoop",
+            supportedTypes: _internals.FlowType.backEndTypes
+        });
+    }
+};

package/main/rules/SameRecordFieldUpdates.d.ts

@@ -0,0 +1,7 @@
+import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class SameRecordFieldUpdates extends AdvancedRule implements core.IRuleDefinition {
+    protected qualifiedRecordTriggerTypes: Set<string>;
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+}

package/main/rules/SameRecordFieldUpdates.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SameRecordFieldUpdates", {
+    enumerable: true,
+    get: function() {
+        return SameRecordFieldUpdates;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _AdvancedRule = require("../models/AdvancedRule");
+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();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let SameRecordFieldUpdates = class SameRecordFieldUpdates extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        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") {
+                results.push(new _internals.ResultDetails(node));
+            }
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            name: "SameRecordFieldUpdates",
+            label: "Same Record Field Updates",
+            description: "Before-save same-record field updates allows you to update the record using variable assignments to `$Record`. This is significantly faster than doing another DML on the same-record that triggered the flow",
+            supportedTypes: [
+                ..._internals.FlowType.backEndTypes
+            ],
+            docRefs: [
+                {
+                    label: "Learn about same record field updates",
+                    path: "https://architect.salesforce.com/decision-guides/trigger-automation#Same_Record_Field_Updates"
+                }
+            ],
+            isConfigurable: false,
+            autoFixable: false
+        }, {
+            severity: "warning"
+        }), _define_property(this, "qualifiedRecordTriggerTypes", new Set([
+            "Create",
+            "Update",
+            "CreateAndUpdate"
+        ]));
+    }
+};

package/main/rules/TriggerOrder.d.ts

@@ -0,0 +1,7 @@
+import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class TriggerOrder extends AdvancedRule implements core.IRuleDefinition {
+    protected qualifiedRecordTriggerTypes: Set<string>;
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+}

package/main/rules/TriggerOrder.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TriggerOrder", {
+    enumerable: true,
+    get: function() {
+        return TriggerOrder;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _AdvancedRule = require("../models/AdvancedRule");
+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();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let TriggerOrder = class TriggerOrder extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const results = [];
+        if (!("object" in flow.start)) {
+            return new _internals.RuleResult(this, results);
+        }
+        if (!flow.triggerOrder) {
+            results.push(new _internals.ResultDetails(new _internals.FlowAttribute("TriggerOrder", "TriggerOrder", "10, 20, 30 ...")));
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        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.",
+            supportedTypes: [
+                _internals.FlowType.autolaunchedType
+            ],
+            docRefs: [
+                {
+                    label: "Learn more about flow ordering orchestration",
+                    path: "https://architect.salesforce.com/decision-guides/trigger-automation#Ordering___Orchestration"
+                }
+            ],
+            isConfigurable: false,
+            autoFixable: false
+        }, {
+            severity: "note"
+        }), _define_property(this, "qualifiedRecordTriggerTypes", new Set([
+            "Create",
+            "Update"
+        ]));
+    }
+};

package/main/rules/UnconnectedElement.d.ts

@@ -0,0 +1,7 @@
+import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class UnconnectedElement extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+    private findStart;
+}

package/main/rules/UnconnectedElement.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UnconnectedElement", {
+    enumerable: true,
+    get: function() {
+        return UnconnectedElement;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _AdvancedRule = require("../models/AdvancedRule");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let UnconnectedElement = class UnconnectedElement extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const connectedElements = new Set();
+        // Callback function to log connected elements
+        const logConnected = (element)=>{
+            connectedElements.add(element.name);
+        };
+        // Get Traversable Nodes
+        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+        // Find start of Flow
+        const startIndex = this.findStart(flowElements);
+        // Start traversal from the start node
+        if (startIndex !== -1) {
+            new _internals.Compiler().traverseFlow(flow, flowElements[startIndex].name, logConnected);
+        }
+        const unconnectedElements = flowElements.filter((element)=>!connectedElements.has(element.name));
+        // Create result details
+        const results = unconnectedElements.map((det)=>new _internals.ResultDetails(det));
+        return new _internals.RuleResult(this, results);
+    }
+    findStart(nodes) {
+        return nodes.findIndex((n)=>{
+            return n.subtype === "start";
+        });
+    }
+    constructor(){
+        super({
+            autoFixable: true,
+            description: "To maintain the efficiency and manageability of your Flow, it's best to avoid including unconnected elements that are not in use.",
+            docRefs: [],
+            isConfigurable: false,
+            label: "Unconnected Element",
+            name: "UnconnectedElement",
+            supportedTypes: [
+                ..._internals.FlowType.backEndTypes,
+                ..._internals.FlowType.visualTypes
+            ]
+        });
+    }
+};

package/main/rules/UnsafeRunningContext.d.ts

@@ -0,0 +1,6 @@
+import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class UnsafeRunningContext extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+}

package/main/rules/UnsafeRunningContext.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UnsafeRunningContext", {
+    enumerable: true,
+    get: function() {
+        return UnsafeRunningContext;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _AdvancedRule = require("../models/AdvancedRule");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let UnsafeRunningContext = class UnsafeRunningContext extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const hasRunInMode = "runInMode" in flow.xmldata;
+        const runInMode = hasRunInMode ? flow.xmldata.runInMode : undefined;
+        const riskyMode = "SystemModeWithoutSharing";
+        const results = [];
+        if (hasRunInMode && runInMode === riskyMode) {
+            results.push(new _internals.ResultDetails(new _internals.FlowAttribute(runInMode, "runInMode", `== ${riskyMode}`)));
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            name: "UnsafeRunningContext",
+            label: "Unsafe Running Context",
+            description: `This flow is configured to run in System Mode without Sharing. This system context grants all running users the permission to view and edit all data in your org. Running a flow in System Mode without Sharing can lead to unsafe data access.`,
+            supportedTypes: [
+                ..._internals.FlowType.backEndTypes,
+                ..._internals.FlowType.visualTypes
+            ],
+            docRefs: [
+                {
+                    label: "Learn about data safety when running flows in system context in Salesforce Help",
+                    path: "https://help.salesforce.com/s/articleView?id=sf.flow_distribute_context_data_safety_system_context.htm&type=5"
+                }
+            ],
+            isConfigurable: false,
+            autoFixable: false
+        }, {
+            severity: "warning"
+        });
+    }
+};

package/main/rules/UnusedVariable.d.ts

@@ -0,0 +1,6 @@
+import { AdvancedRule } from "../models/AdvancedRule";
+import * as core from "../internals/internals";
+export declare class UnusedVariable extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    execute(flow: core.Flow): core.RuleResult;
+}