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

package/main/models/ResultDetails.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ResultDetails", {
+    enumerable: true,
+    get: function() {
+        return ResultDetails;
+    }
+});
+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;
+}
+let ResultDetails = class ResultDetails {
+    constructor(violation){
+        _define_property(this, "violation", void 0);
+        _define_property(this, "name", void 0);
+        _define_property(this, "type", void 0);
+        _define_property(this, "metaType", void 0);
+        _define_property(this, "details", void 0);
+        this.violation = violation;
+        this.name = violation.name;
+        this.metaType = violation.metaType;
+        this.type = violation.subtype;
+        if (violation.metaType === "variable") {
+            const element = violation;
+            this.details = {
+                dataType: element.dataType
+            };
+        }
+        if (violation.metaType === "node") {
+            var _element_connectors;
+            const element = violation;
+            this.details = {
+                locationX: element.locationX,
+                locationY: element.locationY,
+                connectsTo: (_element_connectors = element.connectors) === null || _element_connectors === void 0 ? void 0 : _element_connectors.map((connector)=>connector.reference)
+            };
+        }
+        if (violation.metaType === "attribute") {
+            const element = violation;
+            this.details = {
+                expression: element.expression
+            };
+        }
+    }
+};

package/main/models/RuleCommon.d.ts

@@ -0,0 +1,19 @@
+import { RuleInfo } from "./RuleInfo";
+export declare class RuleCommon {
+    autoFixable: boolean;
+    description: string;
+    docRefs: Array<{
+        label: string;
+        path: string;
+    }>;
+    isConfigurable: boolean;
+    label: any;
+    name: any;
+    severity?: any;
+    supportedTypes: string[];
+    suppressionElement?: string;
+    uri: any;
+    constructor(info: RuleInfo, optional?: {
+        severity?: string;
+    });
+}

package/main/models/RuleCommon.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RuleCommon", {
+    enumerable: true,
+    get: function() {
+        return 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;
+}
+let RuleCommon = class RuleCommon {
+    constructor(info, optional){
+        _define_property(this, "autoFixable", void 0);
+        _define_property(this, "description", void 0);
+        _define_property(this, "docRefs", []);
+        _define_property(this, "isConfigurable", void 0);
+        _define_property(this, "label", void 0);
+        _define_property(this, "name", void 0);
+        _define_property(this, "severity", void 0);
+        _define_property(this, "supportedTypes", void 0);
+        _define_property(this, "suppressionElement", void 0);
+        _define_property(this, "uri", void 0);
+        this.name = info.name;
+        this.supportedTypes = info.supportedTypes;
+        this.label = info.label;
+        this.description = info.description;
+        this.uri = `https://github.com/Lightning-Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/${info.name}.ts`;
+        this.docRefs = info.docRefs;
+        this.isConfigurable = info.isConfigurable;
+        this.autoFixable = info.autoFixable;
+        var _optional_severity;
+        this.severity = (_optional_severity = optional === null || optional === void 0 ? void 0 : optional.severity) !== null && _optional_severity !== void 0 ? _optional_severity : "error";
+        this.suppressionElement = info.suppressionElement;
+    }
+};

package/main/models/RuleInfo.d.ts

@@ -0,0 +1,55 @@
+export type RuleDefinitionExpression = {
+    options?: {
+        expression?: unknown;
+    };
+};
+/**
+ * Represents a rule metadata; this contains properties to describe the rule
+ */
+export declare class RuleInfo {
+    /**
+     * Indicates whether the rule can be automatically fixed.
+     * When the rule is autofixable, implement @see {AutoFixable}
+     */
+    autoFixable: boolean;
+    /**
+     * A human-readable description of the rule.
+     */
+    description: string;
+    /**
+     * An array of documentation references related to the rule.
+     */
+    docRefs: Array<{
+        label: string;
+        path: string;
+    }>;
+    /**
+     * Specifies if the rule's behavior can be configured.
+     * When configurable, execute should take in a second parameter @see RuleDefinitionExpression
+     * @example
+     * ```typescript
+     * public execute(flow: core.Flow, options?: { expression: string }): core.RuleResult {
+     *   // your rule
+     * }
+     */
+    isConfigurable: boolean;
+    /**
+     * The display label for the rule.
+     * This property is being displayed on sf cli and on vsce
+     */
+    label: string;
+    /**
+     * The unique name identifier for the rule.
+     */
+    name: string;
+    /**
+     * The types supported by this rule (e.g., Flow, Process).
+     * Use defined types in @see FlowType
+     */
+    supportedTypes: string[];
+    /**
+     * (Optional) The element that can be used to suppress this rule.
+     * @see AdvancedSuppression
+     */
+    suppressionElement?: string;
+}

package/main/models/RuleInfo.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RuleInfo", {
+    enumerable: true,
+    get: function() {
+        return RuleInfo;
+    }
+});
+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;
+}
+let RuleInfo = class RuleInfo {
+    constructor(){
+        /**
+   * Indicates whether the rule can be automatically fixed.
+   * When the rule is autofixable, implement @see {AutoFixable}
+   */ _define_property(this, "autoFixable", void 0);
+        /**
+   * A human-readable description of the rule.
+   */ _define_property(this, "description", void 0);
+        /**
+   * An array of documentation references related to the rule.
+   */ _define_property(this, "docRefs", void 0);
+        /**
+   * Specifies if the rule's behavior can be configured.
+   * When configurable, execute should take in a second parameter @see RuleDefinitionExpression
+   * @example
+   * ```typescript
+   * public execute(flow: core.Flow, options?: { expression: string }): core.RuleResult {
+   *   // your rule
+   * }
+   */ _define_property(this, "isConfigurable", void 0);
+        /**
+   * The display label for the rule.
+   * This property is being displayed on sf cli and on vsce
+   */ _define_property(this, "label", void 0);
+        /**
+   * The unique name identifier for the rule.
+   */ _define_property(this, "name", void 0);
+        /**
+   * The types supported by this rule (e.g., Flow, Process).
+   * Use defined types in @see FlowType
+   */ _define_property(this, "supportedTypes", void 0);
+        /**
+   * (Optional) The element that can be used to suppress this rule.
+   * @see AdvancedSuppression
+   */ _define_property(this, "suppressionElement", void 0);
+    }
+};

package/main/models/RuleResult.d.ts

@@ -0,0 +1,11 @@
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+import { ResultDetails } from "./ResultDetails";
+export declare class RuleResult {
+    occurs: boolean;
+    ruleName: string;
+    ruleDefinition: IRuleDefinition;
+    severity: string;
+    details: ResultDetails[];
+    errorMessage: string;
+    constructor(info: IRuleDefinition, details: ResultDetails[], errorMessage?: string);
+}

package/main/models/RuleResult.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RuleResult", {
+    enumerable: true,
+    get: function() {
+        return RuleResult;
+    }
+});
+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;
+}
+let RuleResult = class RuleResult {
+    constructor(info, details, errorMessage){
+        _define_property(this, "occurs", void 0);
+        _define_property(this, "ruleName", void 0);
+        _define_property(this, "ruleDefinition", void 0);
+        _define_property(this, "severity", void 0);
+        _define_property(this, "details", []);
+        _define_property(this, "errorMessage", void 0);
+        this.ruleDefinition = info;
+        this.ruleName = info.name;
+        this.severity = info.severity ? info.severity : "error";
+        this.occurs = false;
+        this.details = details;
+        if (details.length > 0) {
+            this.occurs = true;
+        }
+        if (errorMessage) {
+            this.errorMessage = errorMessage;
+        }
+    }
+};

package/main/models/ScanResult.d.ts

@@ -0,0 +1,7 @@
+import { Flow } from "./Flow";
+import { RuleResult } from "./RuleResult";
+export declare class ScanResult {
+    constructor(flow: Flow, ruleResults: RuleResult[]);
+    flow: Flow;
+    ruleResults: RuleResult[];
+}

package/main/models/ScanResult.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ScanResult", {
+    enumerable: true,
+    get: function() {
+        return ScanResult;
+    }
+});
+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;
+}
+let ScanResult = class ScanResult {
+    constructor(flow, ruleResults){
+        _define_property(this, "flow", void 0);
+        _define_property(this, "ruleResults", void 0);
+        this.flow = flow;
+        this.ruleResults = ruleResults;
+    }
+};

package/main/rules/APIVersion.d.ts

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

package/main/rules/APIVersion.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "APIVersion", {
+    enumerable: true,
+    get: function() {
+        return APIVersion;
+    }
+});
+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 APIVersion = class APIVersion extends _AdvancedRule.AdvancedRule {
+    execute(flow, options) {
+        let flowAPIVersionNumber = null;
+        if (flow.xmldata.apiVersion) {
+            const flowAPIVersion = flow.xmldata.apiVersion;
+            flowAPIVersionNumber = +flowAPIVersion;
+        }
+        const results = [];
+        if (!flowAPIVersionNumber) {
+            results.push(new _internals.ResultDetails(new _internals.FlowAttribute("API Version <49", "apiVersion", "<49")));
+            return new _internals.RuleResult(this, results);
+        }
+        if (options && options.expression) {
+            // eslint-disable-next-line sonarjs/code-eval
+            const isApiNumberMoreThanConfiguredExpression = new Function(`return ${flowAPIVersionNumber}${options.expression};`);
+            if (!isApiNumberMoreThanConfiguredExpression()) {
+                results.push(new _internals.ResultDetails(new _internals.FlowAttribute(`${flowAPIVersionNumber}`, "apiVersion", options.expression)));
+            }
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            name: "APIVersion",
+            label: "Outdated API Version",
+            description: "Introducing newer API components may lead to unexpected issues with older versions of Flows, as they might not align with the underlying mechanics. Starting from API version 50.0, the 'Api Version' attribute has been readily available on the Flow Object. To ensure smooth operation and reduce discrepancies between API versions, it is strongly advised to regularly update and maintain them.",
+            supportedTypes: _internals.FlowType.allTypes(),
+            docRefs: [],
+            isConfigurable: true,
+            autoFixable: false
+        });
+    }
+};

package/main/rules/ActionCallsInLoop.d.ts

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

package/main/rules/ActionCallsInLoop.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ActionCallsInLoop", {
+    enumerable: true,
+    get: function() {
+        return ActionCallsInLoop;
+    }
+});
+const _internals = require("../internals/internals");
+const _LoopRuleCommon = require("../models/LoopRuleCommon");
+let ActionCallsInLoop = class ActionCallsInLoop extends _LoopRuleCommon.LoopRuleCommon {
+    getStatementTypes() {
+        return [
+            "actionCalls",
+            "apexPluginCalls"
+        ];
+    }
+    constructor(){
+        super({
+            autoFixable: false,
+            description: "To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilize a single action call containing a collection variable at the end of the loop.",
+            docRefs: [
+                {
+                    label: "Invocable Method Considerations",
+                    path: "https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_annotation_InvocableMethod.htm"
+                }
+            ],
+            isConfigurable: false,
+            label: "**Beta** Action Calls In Loop",
+            name: "ActionCallsInLoop",
+            supportedTypes: _internals.FlowType.backEndTypes
+        }, {
+            severity: "warning"
+        });
+    }
+};

package/main/rules/AutoLayout.d.ts

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

package/main/rules/AutoLayout.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AutoLayout", {
+    enumerable: true,
+    get: function() {
+        return AutoLayout;
+    }
+});
+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 AutoLayout = class AutoLayout extends _AdvancedRule.AdvancedRule {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute(flow, options) {
+        if (flow.processMetadataValues) {
+            var _CanvasMode_value;
+            const CanvasMode = flow.xmldata.processMetadataValues.find((mdv)=>mdv.name === "CanvasMode");
+            const autoLayout = CanvasMode.value && typeof CanvasMode.value === "object" && CanvasMode.value.stringValue && CanvasMode.value.stringValue === "AUTO_LAYOUT_CANVAS";
+            return !autoLayout ? new _internals.RuleResult(this, [
+                new _internals.ResultDetails(new _internals.FlowAttribute((_CanvasMode_value = CanvasMode.value) === null || _CanvasMode_value === void 0 ? void 0 : _CanvasMode_value.stringValue, "CanvasMode", "!== AUTO_LAYOUT_CANVAS"))
+            ]) : new _internals.RuleResult(this, []);
+        }
+        return new _internals.RuleResult(this, []);
+    }
+    constructor(){
+        super({
+            name: "AutoLayout",
+            label: "Auto-Layout Mode",
+            description: "With Canvas Mode set to Auto-Layout, Elements are spaced, connected, and aligned automatically, keeping your Flow neatly organized thus saving you time.",
+            supportedTypes: _internals.FlowType.allTypes(),
+            docRefs: [],
+            isConfigurable: true,
+            autoFixable: false
+        });
+    }
+};

package/main/rules/CopyAPIName.d.ts

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

package/main/rules/CopyAPIName.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CopyAPIName", {
+    enumerable: true,
+    get: function() {
+        return CopyAPIName;
+    }
+});
+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 CopyAPIName = class CopyAPIName extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+        const copyOfElements = [];
+        for (const element of flowElements){
+            // eslint-disable-next-line sonarjs/concise-regex
+            const copyOf = new RegExp("Copy_[0-9]+_of_[A-Za-z0-9]+").test(element.name);
+            if (copyOf) {
+                copyOfElements.push(element);
+            }
+        }
+        const results = [];
+        for (const det of copyOfElements){
+            results.push(new _internals.ResultDetails(det));
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            name: "CopyAPIName",
+            label: "Copy API Name",
+            description: "Maintaining multiple elements with a similar name, like 'Copy_X_Of_Element,' can diminish the overall readability of your Flow. When copying and pasting these elements, it's crucial to remember to update the API name of the newly created copy.",
+            supportedTypes: _internals.FlowType.allTypes(),
+            docRefs: [],
+            isConfigurable: false,
+            autoFixable: false
+        });
+    }
+};

package/main/rules/CyclomaticComplexity.d.ts

@@ -0,0 +1,10 @@
+import { AdvancedRule } from "../models/AdvancedRule";
+import * as core from "../internals/internals";
+export declare class CyclomaticComplexity extends AdvancedRule implements core.IRuleDefinition {
+    constructor();
+    private defaultThreshold;
+    private cyclomaticComplexityUnit;
+    execute(flow: core.Flow, options?: {
+        threshold: number;
+    }): core.RuleResult;
+}