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

package/main/rules/HardcodedId.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HardcodedId", {
+    enumerable: true,
+    get: function() {
+        return HardcodedId;
+    }
+});
+const _AdvancedRule = require("../models/AdvancedRule");
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+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 HardcodedId = class HardcodedId extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const nodesWithHardcodedIds = [];
+        const salesforceIdRegex = /\b[a-zA-Z0-9]{5}0[a-zA-Z0-9]{9}([a-zA-Z0-9]{3})?\b/g;
+        for (const node of flow.elements){
+            const nodeString = JSON.stringify(node);
+            if (salesforceIdRegex.test(nodeString)) {
+                nodesWithHardcodedIds.push(node);
+            }
+        }
+        const results = nodesWithHardcodedIds.map((node)=>new _internals.ResultDetails(node));
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            name: "HardcodedId",
+            label: "Hardcoded Id",
+            description: "Avoid hard-coding IDs as they are org-specific. Instead, pass them into variables at the start of the flow. You can achieve this by utilizing merge fields in URL parameters or employing a Get Records element.",
+            supportedTypes: _internals.FlowType.allTypes(),
+            docRefs: [
+                {
+                    label: "Flow Best Practices",
+                    path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5"
+                },
+                {
+                    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"
+                }
+            ],
+            isConfigurable: false,
+            autoFixable: false
+        });
+    }
+};

package/main/rules/HardcodedUrl.d.ts

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

package/main/rules/HardcodedUrl.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HardcodedUrl", {
+    enumerable: true,
+    get: function() {
+        return HardcodedUrl;
+    }
+});
+const _internals = require("../internals/internals");
+const _AdvancedRule = require("../models/AdvancedRule");
+let HardcodedUrl = class HardcodedUrl extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        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)) {
+                results.push(new _internals.ResultDetails(element));
+            }
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "Avoid hard-coding URLs as they are org-specific. Instead, use a $API formula (preferred) or you can use an environment-specific such as custom labels, custom metadata, or custom settings.",
+            docRefs: [
+                {
+                    label: "The Ultimate Guide to Salesforce Flow Best Practices",
+                    path: "https://admin.salesforce.com/blog/2021/the-ultimate-guide-to-flow-best-practices-and-standards"
+                },
+                {
+                    label: "Why You Should Avoid Hard Coding and Three Alternative Solutions",
+                    path: "https://admin.salesforce.com/blog/2021/why-you-should-avoid-hard-coding-and-three-alternative-solutions"
+                }
+            ],
+            isConfigurable: false,
+            label: "Hardcoded Url",
+            name: "HardcodedUrl",
+            supportedTypes: _internals.FlowType.allTypes()
+        }, {
+            severity: "warning"
+        });
+    }
+};

package/main/rules/InactiveFlow.d.ts

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

package/main/rules/InactiveFlow.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "InactiveFlow", {
+    enumerable: true,
+    get: function() {
+        return InactiveFlow;
+    }
+});
+const _AdvancedRule = require("../models/AdvancedRule");
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+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 InactiveFlow = class InactiveFlow extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const results = [];
+        if (flow.status !== "Active") {
+            results.push(new _internals.ResultDetails(new _internals.FlowAttribute(flow.status, "status", "!= Active")));
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            name: "InactiveFlow",
+            label: "Inactive Flow",
+            description: "Like cleaning out your closet: deleting unused flows is essential. Inactive flows can still cause trouble, like accidentally deleting records during testing, or being activated as subflows within parent flows.",
+            supportedTypes: _internals.FlowType.allTypes(),
+            docRefs: [],
+            isConfigurable: false,
+            autoFixable: false
+        });
+    }
+};

package/main/rules/MissingFaultPath.d.ts

@@ -0,0 +1,12 @@
+import { AdvancedConfig } from "../interfaces/AdvancedRuleConfig";
+import { AdvancedSuppression } from "../interfaces/AdvancedSuppression";
+import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class MissingFaultPath extends AdvancedRule implements AdvancedSuppression, core.IRuleDefinition {
+    protected applicableElements: string[];
+    constructor();
+    private isValidSubtype;
+    execute(flow: core.Flow): core.RuleResult;
+    suppress(scanResult: core.RuleResult, ruleConfiguration?: AdvancedConfig): core.RuleResult;
+    private isPartOfFaultHandlingFlow;
+}

package/main/rules/MissingFaultPath.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MissingFaultPath", {
+    enumerable: true,
+    get: function() {
+        return MissingFaultPath;
+    }
+});
+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 MissingFaultPath = class MissingFaultPath extends _AdvancedRule.AdvancedRule {
+    isValidSubtype(proxyNode) {
+        if (!this.applicableElements.includes(proxyNode.subtype)) {
+            return false;
+        }
+        if (proxyNode.subtype === "waits") {
+            var _proxyNode_element;
+            const elementSubtype = (_proxyNode_element = proxyNode.element) === null || _proxyNode_element === void 0 ? void 0 : _proxyNode_element["elementSubtype"];
+            const excludedSubtypes = [
+                "WaitDuration",
+                "WaitDate"
+            ];
+            return !excludedSubtypes.includes(elementSubtype);
+        }
+        return true;
+    }
+    execute(flow) {
+        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;
+                }
+                // Check if the element is part of another fault path
+                if (!this.isPartOfFaultHandlingFlow(element, flow)) {
+                    results.push(new _internals.ResultDetails(element));
+                }
+            }
+        };
+        // Use the core.Compiler for traversal
+        compiler.traverseFlow(flow, flow.startReference, visitCallback);
+        return new _internals.RuleResult(this, results);
+    }
+    suppress(scanResult, ruleConfiguration) {
+        const suppressedResults = [];
+        const suppressionElementKey = this.suppressionElement;
+        for (const resultDetails of scanResult.details){
+            var _ruleConfiguration_suppressions;
+            if ("violation" in resultDetails && "element" in resultDetails.violation && typeof resultDetails.violation.element === "object" && !Array.isArray(resultDetails.violation.element) && suppressionElementKey in resultDetails.violation.element && (ruleConfiguration === null || ruleConfiguration === void 0 ? void 0 : (_ruleConfiguration_suppressions = ruleConfiguration.suppressions) === null || _ruleConfiguration_suppressions === void 0 ? void 0 : _ruleConfiguration_suppressions.includes(resultDetails.violation.element[suppressionElementKey]))) {
+                continue;
+            }
+            suppressedResults.push(resultDetails);
+        }
+        return new _internals.RuleResult(this, suppressedResults);
+    }
+    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;
+                // Check if the otherElement has a faultConnector pointing to element
+                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;
+                }
+            }
+        }
+        return false;
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            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.",
+            docRefs: [
+                {
+                    label: "Flow Best Practices",
+                    path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5"
+                }
+            ],
+            isConfigurable: false,
+            label: "Missing Fault Path",
+            name: "MissingFaultPath",
+            supportedTypes: [
+                ..._internals.FlowType.backEndTypes,
+                ..._internals.FlowType.visualTypes
+            ],
+            suppressionElement: "actionName"
+        }), _define_property(this, "applicableElements", [
+            "recordLookups",
+            "recordDeletes",
+            "recordUpdates",
+            "recordCreates",
+            "waits",
+            "actionCalls"
+        ]);
+    }
+};

package/main/rules/MissingNullHandler.d.ts

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

package/main/rules/MissingNullHandler.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MissingNullHandler", {
+    enumerable: true,
+    get: function() {
+        return MissingNullHandler;
+    }
+});
+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 MissingNullHandler = class MissingNullHandler extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        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 getOperationsWithoutNullHandler = [];
+        for (const getElement of getOperationElements){
+            const elementName = getElement.name;
+            let nullCheckFound = false;
+            let resultReferences = [];
+            if (getElement.element["storeOutputAutomatically"]) {
+                resultReferences = [
+                    elementName
+                ];
+            } else if (getElement.element["outputReference"]) {
+                resultReferences = getElement.element["outputReference"];
+            } else if (getElement.element["outputAssignments"]) {
+                const outputAssignments = getElement.element["outputAssignments"];
+                for (const assignment of outputAssignments){
+                    resultReferences.push(assignment.assignToReference);
+                }
+            }
+            // ✅ Skip check if result is never used inside the flow
+            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;
+            for (const el of decisionElements){
+                let rules = el.element["rules"];
+                const isRuleAnArray = Array.isArray(rules);
+                if (!isRuleAnArray) {
+                    rules = [
+                        rules
+                    ];
+                }
+                for (const rule of rules){
+                    let conditions = rule.conditions;
+                    const isConditionsAnArray = Array.isArray(conditions);
+                    if (!isConditionsAnArray) {
+                        conditions = [
+                            conditions
+                        ];
+                    }
+                    for (const condition of conditions){
+                        let referenceFound = false;
+                        let isNullOperator = false;
+                        let checksIfFalse = false;
+                        if (condition.leftValueReference && condition.leftValueReference.length > 0) {
+                            const valueReference = condition.leftValueReference;
+                            for (const ref of resultReferences){
+                                referenceFound = valueReference.startsWith(ref);
+                                if (referenceFound) {
+                                    break;
+                                }
+                            }
+                        }
+                        if (condition.operator && (!Array.isArray(condition.operator) || condition.operator.length > 0)) {
+                            const operator = condition.operator;
+                            isNullOperator = operator === "IsNull";
+                        }
+                        if (condition.rightValue && (!Array.isArray(condition.rightValue) || condition.rightValue.length > 0) && condition.rightValue.booleanValue && (!Array.isArray(condition.rightValue.booleanValue) || condition.rightValue.booleanValue.length > 0)) {
+                            const rightValue = condition.rightValue.booleanValue;
+                            checksIfFalse = rightValue.toLowerCase() === "false";
+                        }
+                        if (referenceFound && isNullOperator && checksIfFalse) {
+                            nullCheckFound = true;
+                        }
+                    }
+                }
+            }
+            if (!nullCheckFound) {
+                getOperationsWithoutNullHandler.push(getElement);
+            }
+        }
+        const results = [];
+        for (const det of getOperationsWithoutNullHandler){
+            results.push(new _internals.ResultDetails(det));
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "When a Get Records operation doesn't find any data, it returns null. To ensure data validation, utilize a decision element on the operation result variable to check for a non-null result.",
+            docRefs: [],
+            isConfigurable: false,
+            label: "Missing Null Handler",
+            name: "MissingNullHandler",
+            supportedTypes: [
+                ..._internals.FlowType.backEndTypes,
+                ..._internals.FlowType.visualTypes
+            ]
+        });
+    }
+};

package/main/rules/ProcessBuilder.d.ts

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

package/main/rules/ProcessBuilder.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ProcessBuilder", {
+    enumerable: true,
+    get: function() {
+        return ProcessBuilder;
+    }
+});
+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 ProcessBuilder = class ProcessBuilder extends _AdvancedRule.AdvancedRule {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute(flow, options) {
+        return new _internals.RuleResult(this, [
+            new _internals.ResultDetails(new _internals.FlowAttribute("Workflow", "processType", "== Workflow"))
+        ]);
+    }
+    constructor(){
+        super({
+            name: "ProcessBuilder",
+            label: "No Process Builder",
+            description: "Salesforce is transitioning away from Workflow Rules and Process Builder in favor of Flow. Ensure you're prepared for this transition by migrating your organization's automation to Flow. Refer to official documentation for more information on the transition process and tools available.",
+            supportedTypes: _internals.FlowType.processBuilder,
+            docRefs: [
+                {
+                    label: "Process Builder Retirement",
+                    path: "https://help.salesforce.com/s/articleView?id=000389396&type=1"
+                }
+            ],
+            isConfigurable: true,
+            autoFixable: false
+        });
+    }
+};

package/main/rules/RecursiveAfterUpdate.d.ts

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