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

package/main/models/FlowAttribute.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowAttribute", {
+    enumerable: true,
+    get: function() {
+        return FlowAttribute;
+    }
+});
+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 FlowAttribute = class FlowAttribute {
+    constructor(name, subtype, expression){
+        _define_property(this, "name", void 0);
+        _define_property(this, "subtype", void 0);
+        _define_property(this, "expression", void 0);
+        _define_property(this, "metaType", "attribute");
+        this.name = name;
+        this.subtype = subtype;
+        this.expression = expression;
+    }
+};

package/main/models/FlowElement.d.ts

@@ -0,0 +1,10 @@
+export declare class FlowElement {
+    subtype: string;
+    metaType: string;
+    element: string | object[] | object;
+    connectors?: object[];
+    name?: string;
+    locationX?: string;
+    locationY?: string;
+    constructor(metaType: string, subtype: string, element: object);
+}

package/main/models/FlowElement.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowElement", {
+    enumerable: true,
+    get: function() {
+        return FlowElement;
+    }
+});
+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 FlowElement = class FlowElement {
+    constructor(metaType, subtype, element){
+        _define_property(this, "subtype", void 0);
+        _define_property(this, "metaType", void 0);
+        _define_property(this, "element", {});
+        _define_property(this, "connectors", void 0);
+        _define_property(this, "name", void 0);
+        _define_property(this, "locationX", void 0);
+        _define_property(this, "locationY", void 0);
+        this.element = element;
+        this.subtype = subtype;
+        this.metaType = metaType;
+    }
+};

package/main/models/FlowElementConnector.d.ts

@@ -0,0 +1,15 @@
+export declare class FlowElementConnector {
+    type: string;
+    element: object;
+    processed: boolean;
+    alias: string;
+    reference: string;
+    childName: string;
+    childOf: boolean;
+    connectorTargetReference: FlowElementConnectorReference;
+    constructor(type: string, element: object, args: any);
+}
+declare class FlowElementConnectorReference {
+    targetReference: string;
+}
+export {};

package/main/models/FlowElementConnector.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowElementConnector", {
+    enumerable: true,
+    get: function() {
+        return FlowElementConnector;
+    }
+});
+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 FlowElementConnector = class FlowElementConnector {
+    constructor(type, element, args){
+        _define_property(this, "type", void 0);
+        _define_property(this, "element", {});
+        _define_property(this, "processed", false);
+        _define_property(this, "alias", void 0);
+        _define_property(this, "reference", void 0);
+        _define_property(this, "childName", void 0);
+        _define_property(this, "childOf", void 0);
+        _define_property(this, "connectorTargetReference", void 0);
+        this.type = type;
+        this.element = element;
+        this.childName = args.childName ? args.childName : undefined;
+        this.childOf = args.childOf ? args.childOf : undefined;
+        if (element && "targetReference" in element) {
+            this.reference = element.targetReference;
+        }
+        if (element && "connector" in element) {
+            this.connectorTargetReference = element.connector;
+        }
+    }
+};
+let FlowElementConnectorReference = class FlowElementConnectorReference {
+    constructor(){
+        _define_property(this, "targetReference", void 0);
+    }
+};

package/main/models/FlowMetadata.d.ts

@@ -0,0 +1,4 @@
+import { FlowElement } from "./FlowElement";
+export declare class FlowMetadata extends FlowElement {
+    constructor(subtype: string, element: object);
+}

package/main/models/FlowMetadata.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowMetadata", {
+    enumerable: true,
+    get: function() {
+        return FlowMetadata;
+    }
+});
+const _FlowElement = require("./FlowElement");
+let FlowMetadata = class FlowMetadata extends _FlowElement.FlowElement {
+    constructor(subtype, element){
+        super("metadata", subtype, element);
+    }
+};

package/main/models/FlowNode.d.ts

@@ -0,0 +1,10 @@
+import { FlowElement } from "./FlowElement";
+import { FlowElementConnector } from "./FlowElementConnector";
+export declare class FlowNode extends FlowElement {
+    connectors: FlowElementConnector[];
+    locationX: string;
+    locationY: string;
+    name: string;
+    constructor(provName: string, subtype: string, element: object);
+    private getConnectors;
+}

package/main/models/FlowNode.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowNode", {
+    enumerable: true,
+    get: function() {
+        return FlowNode;
+    }
+});
+const _FlowElement = require("./FlowElement");
+const _FlowElementConnector = require("./FlowElementConnector");
+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 FlowNode = class FlowNode extends _FlowElement.FlowElement {
+    getConnectors(subtype, element) {
+        const connectors = [];
+        if (subtype === "start") {
+            if (element.connector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("connector", element.connector, {}));
+            }
+            if (Array.isArray(element.scheduledPaths)) {
+                for (const asyncElement of (element === null || element === void 0 ? void 0 : element.scheduledPaths) || []){
+                    if (asyncElement.connector) {
+                        var _asyncElement_name;
+                        connectors.push(new _FlowElementConnector.FlowElementConnector("connector", asyncElement.connector, {
+                            childName: (_asyncElement_name = asyncElement === null || asyncElement === void 0 ? void 0 : asyncElement.name) !== null && _asyncElement_name !== void 0 ? _asyncElement_name : "AsyncAfterCommit",
+                            childOf: "scheduledPaths"
+                        }));
+                    }
+                }
+            } else {
+                if (element.scheduledPaths) {
+                    connectors.push(new _FlowElementConnector.FlowElementConnector("connector", element.scheduledPaths, {
+                        childName: element.scheduledPaths.name,
+                        childOf: "scheduledPaths"
+                    }));
+                }
+            }
+            return connectors;
+        } else if (subtype === "decisions") {
+            if (element.defaultConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("defaultConnector", element.defaultConnector, {}));
+            }
+            if (element.rules) {
+                if (Array.isArray(element.rules)) {
+                    for (const rule of element.rules){
+                        if (rule.connector) {
+                            connectors.push(new _FlowElementConnector.FlowElementConnector("connector", rule.connector, {
+                                childName: rule.name,
+                                childOf: "rules"
+                            }));
+                        }
+                    }
+                } else {
+                    if (element.rules.connector) {
+                        connectors.push(new _FlowElementConnector.FlowElementConnector("connector", element.rules.connector, {
+                            childName: element.rules.name,
+                            childOf: "rules"
+                        }));
+                    }
+                }
+            }
+            return connectors;
+        } else if (subtype === "assignments" || subtype === "transforms" || subtype === "customErrors") {
+            return element.connector ? [
+                new _FlowElementConnector.FlowElementConnector("connector", element.connector, {})
+            ] : [];
+        } else if (subtype === "loops") {
+            if (element.nextValueConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("nextValueConnector", element.nextValueConnector, {}));
+            }
+            if (element.noMoreValuesConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("noMoreValuesConnector", element.noMoreValuesConnector, {}));
+            }
+            return connectors;
+        } else if (subtype === "actionCalls") {
+            if (element.connector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("connector", element.connector, {}));
+            }
+            if (element.faultConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("faultConnector", element.faultConnector, {}));
+            }
+            return connectors;
+        } else if (subtype === "waits") {
+            if (element.defaultConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("defaultConnector", element.defaultConnector, {}));
+            }
+            if (element.faultConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("faultConnector", element.faultConnector, {}));
+            }
+            if (Array.isArray(element.waitEvents)) {
+                for (const waitEvent of element.waitEvents){
+                    if (waitEvent.connector) {
+                        connectors.push(new _FlowElementConnector.FlowElementConnector("connector", waitEvent.connector, {
+                            childName: waitEvent.name,
+                            childOf: "waitEvents"
+                        }));
+                    }
+                }
+            }
+            return connectors;
+        } else if (subtype === "recordCreates") {
+            if (element.connector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("connector", element.connector, {}));
+            }
+            if (element.faultConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("faultConnector", element.faultConnector, {}));
+            }
+            return connectors;
+        } else if (subtype === "recordDeletes") {
+            if (element.connector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("connector", element.connector, {}));
+            }
+            if (element.faultConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("faultConnector", element.faultConnector, {}));
+            }
+            return connectors;
+        } else if (subtype === "recordLookups") {
+            if (element.connector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("connector", element.connector, {}));
+            }
+            if (element.faultConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("faultConnector", element.faultConnector, {}));
+            }
+            return connectors;
+        } else if (subtype === "recordUpdates") {
+            if (element.connector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("connector", element.connector, {}));
+            }
+            if (element.faultConnector) {
+                connectors.push(new _FlowElementConnector.FlowElementConnector("faultConnector", element.faultConnector, {}));
+            }
+            return connectors;
+        } else if (subtype === "subflows") {
+            return element.connector ? [
+                new _FlowElementConnector.FlowElementConnector("connector", element.connector, {})
+            ] : [];
+        } else if (subtype === "screens") {
+            return element.connector ? [
+                new _FlowElementConnector.FlowElementConnector("connector", element.connector, {})
+            ] : [];
+        } else {
+            return element.connector ? [
+                new _FlowElementConnector.FlowElementConnector("connector", element.connector, {})
+            ] : [];
+        }
+    }
+    constructor(provName, subtype, element){
+        super("node", subtype, element), _define_property(this, "connectors", []), _define_property(this, "locationX", void 0), _define_property(this, "locationY", void 0), _define_property(this, "name", void 0);
+        const nodeName = subtype === "start" ? "flowstart" : provName;
+        this.name = nodeName;
+        const connectors = this.getConnectors(subtype, element);
+        this.connectors = connectors;
+        this.locationX = element["locationX"];
+        this.locationY = element["locationY"];
+    }
+};

package/main/models/FlowResource.d.ts

@@ -0,0 +1,5 @@
+import { FlowElement } from "./FlowElement";
+export declare class FlowResource extends FlowElement {
+    name: string;
+    constructor(name: string, subtype: string, element: object);
+}

package/main/models/FlowResource.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowResource", {
+    enumerable: true,
+    get: function() {
+        return FlowResource;
+    }
+});
+const _FlowElement = require("./FlowElement");
+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 FlowResource = class FlowResource extends _FlowElement.FlowElement {
+    constructor(name, subtype, element){
+        super("resource", subtype, element), _define_property(this, "name", void 0);
+        this.name = name;
+    }
+};

package/main/models/FlowType.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Represents the different types of Salesforce Flows and provides utility methods
+ * to categorize and retrieve them.
+ *
+ * @remarks
+ * This class defines static properties for various flow types, including backend,
+ * process builder, survey, visual, and unsupported types. It also provides a method
+ * to retrieve all supported flow types.
+ *
+ * @example
+ * ```typescript
+ * const allFlowTypes = FlowType.allTypes();
+ * ```
+ */
+export declare class FlowType {
+    static readonly autolaunchedType = "AutoLaunchedFlow";
+    static readonly backEndTypes: string[];
+    static readonly processBuilder: string[];
+    static readonly surveyTypes: string[];
+    static readonly unsupportedTypes: string[];
+    static readonly visualTypes: string[];
+    static readonly allTypes: () => any[];
+}

package/main/models/FlowType.js

@@ -0,0 +1,80 @@
+/**
+ * Represents the different types of Salesforce Flows and provides utility methods
+ * to categorize and retrieve them.
+ *
+ * @remarks
+ * This class defines static properties for various flow types, including backend,
+ * process builder, survey, visual, and unsupported types. It also provides a method
+ * to retrieve all supported flow types.
+ *
+ * @example
+ * ```typescript
+ * const allFlowTypes = FlowType.allTypes();
+ * ```
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowType", {
+    enumerable: true,
+    get: function() {
+        return FlowType;
+    }
+});
+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 FlowType = class FlowType {
+};
+_define_property(FlowType, "autolaunchedType", "AutoLaunchedFlow");
+_define_property(FlowType, "backEndTypes", [
+    FlowType.autolaunchedType,
+    "CustomEvent",
+    "InvocableProcess",
+    "Orchestrator",
+    "EvaluationFlow",
+    "ActionCadenceAutolaunchedFlow"
+]);
+_define_property(FlowType, "processBuilder", [
+    "Workflow"
+]);
+_define_property(FlowType, "surveyTypes", [
+    "Survey"
+]);
+_define_property(FlowType, "unsupportedTypes", [
+    "CheckoutFlow",
+    "FSCLending",
+    "FSCLending",
+    "LoyaltyManagementFlow"
+]);
+_define_property(FlowType, "visualTypes", [
+    "Flow",
+    "IndividualObjectLinkingFlow",
+    "LoginFlow",
+    "RoutingFlow",
+    "Appointments",
+    "ActionCadenceStepFlow",
+    "ContactRequestFlow",
+    "ContactRequestFlow",
+    "CustomerLifecycle",
+    "FieldServiceMobile",
+    "FieldServiceWeb",
+    "SurveyEnrich"
+]);
+_define_property(FlowType, "allTypes", function() {
+    return [
+        ...this.backEndTypes,
+        ...this.visualTypes,
+        ...this.surveyTypes
+    ];
+});

package/main/models/FlowVariable.d.ts

@@ -0,0 +1,6 @@
+import { FlowElement } from "./FlowElement";
+export declare class FlowVariable extends FlowElement {
+    name: string;
+    dataType: string;
+    constructor(name: string, subtype: string, element: object);
+}

package/main/models/FlowVariable.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlowVariable", {
+    enumerable: true,
+    get: function() {
+        return FlowVariable;
+    }
+});
+const _FlowElement = require("./FlowElement");
+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 FlowVariable = class FlowVariable extends _FlowElement.FlowElement {
+    constructor(name, subtype, element){
+        super("variable", subtype, element), _define_property(this, "name", void 0), _define_property(this, "dataType", void 0);
+        this.name = name;
+        this.dataType = element["dataType"];
+    }
+};

package/main/models/LoopRuleCommon.d.ts

@@ -0,0 +1,9 @@
+import { Flow, RuleResult } from "../internals/internals";
+import { AdvancedRule } from "./AdvancedRule";
+export declare abstract class LoopRuleCommon extends AdvancedRule {
+    execute(flow: Flow): RuleResult;
+    protected abstract getStatementTypes(): string[];
+    private findLoopElements;
+    private findLoopEnd;
+    private findStatementsInLoops;
+}

package/main/models/LoopRuleCommon.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LoopRuleCommon", {
+    enumerable: true,
+    get: function() {
+        return LoopRuleCommon;
+    }
+});
+const _internals = require("../internals/internals");
+const _AdvancedRule = require("./AdvancedRule");
+let LoopRuleCommon = class LoopRuleCommon extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const loopElements = this.findLoopElements(flow);
+        if (!loopElements.length) {
+            return new _internals.RuleResult(this, []);
+        }
+        const statementsInLoops = this.findStatementsInLoops(flow, loopElements);
+        const results = statementsInLoops.map((det)=>new _internals.ResultDetails(det));
+        return new _internals.RuleResult(this, results);
+    }
+    findLoopElements(flow) {
+        var _flow_elements;
+        return ((_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "loops")) || [];
+    }
+    findLoopEnd(element) {
+        var _element_element_noMoreValuesConnector;
+        var _element_element_noMoreValuesConnector_targetReference;
+        return (_element_element_noMoreValuesConnector_targetReference = (_element_element_noMoreValuesConnector = element.element["noMoreValuesConnector"]) === null || _element_element_noMoreValuesConnector === void 0 ? void 0 : _element_element_noMoreValuesConnector.targetReference) !== null && _element_element_noMoreValuesConnector_targetReference !== void 0 ? _element_element_noMoreValuesConnector_targetReference : element.name;
+    }
+    findStatementsInLoops(flow, loopElements) {
+        const statementsInLoops = [];
+        const statementTypes = this.getStatementTypes();
+        const findStatement = (element)=>{
+            if (statementTypes.includes(element.subtype)) {
+                statementsInLoops.push(element);
+            }
+        };
+        for (const element of loopElements){
+            const loopEnd = this.findLoopEnd(element);
+            // decide if we should count fault connectors as a violation
+            // if (typeof element.element === "object" && "faultConnector" in (element.element as object)) {}
+            new _internals.Compiler().traverseFlow(flow, element.name, findStatement, loopEnd);
+        }
+        return statementsInLoops;
+    }
+};

package/main/models/ParsedFlow.d.ts

@@ -0,0 +1,7 @@
+import { Flow } from "./Flow";
+export declare class ParsedFlow {
+    uri: string;
+    flow: Flow | undefined;
+    errorMessage?: string;
+    constructor(uri: string, flow: Flow, errorMessage?: string);
+}

package/main/models/ParsedFlow.js

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

package/main/models/ResultDetails.d.ts

@@ -0,0 +1,10 @@
+import { FlowElement } from "../internals/internals";
+import { FlowAttribute } from "./FlowAttribute";
+export declare class ResultDetails {
+    violation: FlowAttribute | FlowElement;
+    name: string;
+    type: string;
+    metaType: string;
+    details: object;
+    constructor(violation: FlowAttribute | FlowElement);
+}