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

package/main/internals/internals.d.ts

@@ -0,0 +1,17 @@
+import type { IRuleDefinition } from "../interfaces/IRuleDefinition";
+import type { IRulesConfig } from "../interfaces/IRulesConfig";
+import { Compiler } from "../libs/Compiler";
+import { Flow } from "../models/Flow";
+import { FlowAttribute } from "../models/FlowAttribute";
+import { FlowElement } from "../models/FlowElement";
+import { FlowType } from "../models/FlowType";
+import { FlowNode } from "../models/FlowNode";
+import { FlowResource } from "../models/FlowResource";
+import { FlowVariable } from "../models/FlowVariable";
+import { ResultDetails } from "../models/ResultDetails";
+import { RuleResult } from "../models/RuleResult";
+import { ScanResult } from "../models/ScanResult";
+import { RuleCommon } from "../models/RuleCommon";
+import { ParsedFlow } from "../models/ParsedFlow";
+export { FlowAttribute, FlowElement, FlowNode, FlowType, FlowVariable, FlowResource, Flow, Compiler, ScanResult, RuleResult, ResultDetails, RuleCommon, ParsedFlow, };
+export type { IRuleDefinition, IRulesConfig };

package/main/internals/internals.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Compiler () {
+        return _Compiler.Compiler;
+    },
+    get Flow () {
+        return _Flow.Flow;
+    },
+    get FlowAttribute () {
+        return _FlowAttribute.FlowAttribute;
+    },
+    get FlowElement () {
+        return _FlowElement.FlowElement;
+    },
+    get FlowNode () {
+        return _FlowNode.FlowNode;
+    },
+    get FlowResource () {
+        return _FlowResource.FlowResource;
+    },
+    get FlowType () {
+        return _FlowType.FlowType;
+    },
+    get FlowVariable () {
+        return _FlowVariable.FlowVariable;
+    },
+    get ParsedFlow () {
+        return _ParsedFlow.ParsedFlow;
+    },
+    get ResultDetails () {
+        return _ResultDetails.ResultDetails;
+    },
+    get RuleCommon () {
+        return _RuleCommon.RuleCommon;
+    },
+    get RuleResult () {
+        return _RuleResult.RuleResult;
+    },
+    get ScanResult () {
+        return _ScanResult.ScanResult;
+    }
+});
+const _Compiler = require("../libs/Compiler");
+const _Flow = require("../models/Flow");
+const _FlowAttribute = require("../models/FlowAttribute");
+const _FlowElement = require("../models/FlowElement");
+const _FlowType = require("../models/FlowType");
+const _FlowNode = require("../models/FlowNode");
+const _FlowResource = require("../models/FlowResource");
+const _FlowVariable = require("../models/FlowVariable");
+const _ResultDetails = require("../models/ResultDetails");
+const _RuleResult = require("../models/RuleResult");
+const _ScanResult = require("../models/ScanResult");
+const _RuleCommon = require("../models/RuleCommon");
+const _ParsedFlow = require("../models/ParsedFlow");

package/main/libs/BuildFlow.d.ts

@@ -0,0 +1 @@
+export declare function BuildFlow(nodesToMerge: any): {};

package/main/libs/BuildFlow.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BuildFlow", {
+    enumerable: true,
+    get: function() {
+        return BuildFlow;
+    }
+});
+const _ConvertFlowNodes = require("./ConvertFlowNodes");
+function BuildFlow(nodesToMerge) {
+    let res = {};
+    for (const nodeToMerge of nodesToMerge){
+        const subtype = nodeToMerge.subtype;
+        const nodesOfType = nodesToMerge.filter((node)=>subtype === node.subtype);
+        res = (0, _ConvertFlowNodes.convertFlowNodes)(res, nodesOfType, subtype);
+    }
+    return res;
+}

package/main/libs/Compiler.d.ts

@@ -0,0 +1,8 @@
+import { Flow } from "../models/Flow";
+import { FlowNode } from "../models/FlowNode";
+export declare class Compiler {
+    visitedElements: Set<string>;
+    constructor();
+    traverseFlow(flow: Flow, startElementName: string, visitCallback: (element: FlowNode) => void, endElementName?: string): void;
+    private findNextElements;
+}

package/main/libs/Compiler.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Compiler", {
+    enumerable: true,
+    get: function() {
+        return Compiler;
+    }
+});
+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 Compiler = class Compiler {
+    traverseFlow(flow, startElementName, visitCallback, endElementName) {
+        // Iterative Deepening Depth-First Search (IDDFS)
+        let elementsToVisit = [
+            startElementName
+        ];
+        while(elementsToVisit.length > 0){
+            const nextElements = [];
+            for (const elementName of elementsToVisit){
+                if (!this.visitedElements.has(elementName)) {
+                    var _flow_elements;
+                    const currentElement = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.find((element)=>element.name === elementName);
+                    if (currentElement) {
+                        visitCallback(currentElement);
+                        this.visitedElements.add(elementName);
+                        nextElements.push(...this.findNextElements(flow, currentElement, endElementName));
+                    }
+                }
+            }
+            if (nextElements.length === 0) {
+                break; // Terminate the traversal
+            }
+            elementsToVisit = nextElements;
+        }
+    }
+    findNextElements(flow, currentElement, endElementName) {
+        const nextElements = [];
+        if (!currentElement.connectors || currentElement.connectors.length === 0) {
+            return nextElements;
+        }
+        for (const connector of currentElement.connectors){
+            var _connector_connectorTargetReference, _flow_elements;
+            var _connector_connectorTargetReference_targetReference;
+            const targetReference = (_connector_connectorTargetReference_targetReference = connector === null || connector === void 0 ? void 0 : (_connector_connectorTargetReference = connector.connectorTargetReference) === null || _connector_connectorTargetReference === void 0 ? void 0 : _connector_connectorTargetReference.targetReference) !== null && _connector_connectorTargetReference_targetReference !== void 0 ? _connector_connectorTargetReference_targetReference : connector.reference;
+            // Check if the reference exists in the flow elements
+            const nextElement = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.find((element)=>element.metaType === "node" && element.name === targetReference);
+            if (nextElement && nextElement.metaType === "node" && nextElement.name !== endElementName) {
+                nextElements.push(nextElement.name);
+            }
+        }
+        return nextElements;
+    }
+    constructor(){
+        _define_property(this, "visitedElements", void 0);
+        this.visitedElements = new Set();
+    }
+};

package/main/libs/ConvertFlowNodes.d.ts

@@ -0,0 +1 @@
+export declare function convertFlowNodes(obj: any, nodes: any, key: any): any;

package/main/libs/ConvertFlowNodes.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "convertFlowNodes", {
+    enumerable: true,
+    get: function() {
+        return convertFlowNodes;
+    }
+});
+function convertFlowNodes(obj, nodes, key) {
+    obj[key] = nodes.map((node)=>node.element);
+    return obj;
+}

package/main/libs/DynamicRule.d.ts

@@ -0,0 +1,5 @@
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+import { AdvancedRule } from "../models/AdvancedRule";
+export declare class DynamicRule<T extends AdvancedRule | IRuleDefinition> {
+    constructor(className: string);
+}

package/main/libs/DynamicRule.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DynamicRule", {
+    enumerable: true,
+    get: function() {
+        return DynamicRule;
+    }
+});
+const _DefaultRuleStore = require("../store/DefaultRuleStore");
+let DynamicRule = class DynamicRule {
+    constructor(className){
+        if (!_DefaultRuleStore.DefaultRuleStore.hasOwnProperty(className) && _DefaultRuleStore.BetaRuleStore.hasOwnProperty(className)) {
+            return new _DefaultRuleStore.BetaRuleStore[className]();
+        }
+        return new _DefaultRuleStore.DefaultRuleStore[className]();
+    }
+};

package/main/libs/FixFlows.d.ts

@@ -0,0 +1,3 @@
+import * as core from "../internals/internals";
+export declare function fix(results: core.ScanResult[]): core.ScanResult[];
+export declare function FixFlows(flow: core.Flow, ruleResults: core.RuleResult[]): core.Flow;

package/main/libs/FixFlows.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get FixFlows () {
+        return FixFlows;
+    },
+    get fix () {
+        return fix;
+    }
+});
+const _BuildFlow = require("./BuildFlow");
+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;
+}
+function fix(results) {
+    const newResults = [];
+    for (const result of results){
+        if (result.ruleResults && result.ruleResults.length > 0) {
+            const fixables = result.ruleResults.filter((r)=>r.ruleName === "UnusedVariable" && r.occurs || r.ruleName === "UnconnectedElement" && r.occurs // TODO: this should be rule.occurs && rule.ruleDefinition.fixable
+            );
+            if ((fixables === null || fixables === void 0 ? void 0 : fixables.length) > 0) {
+                const newFlow = FixFlows(result.flow, fixables);
+                result.flow = newFlow;
+                newResults.push(result);
+            }
+        }
+    }
+    return newResults;
+}
+function FixFlows(flow, ruleResults) {
+    var _flow_elements;
+    // TODO: this should be defined on the rule
+    const unusedVariableRes = ruleResults.find((r)=>r.ruleName === "UnusedVariable");
+    const unusedVariableReferences = unusedVariableRes && unusedVariableRes.details && unusedVariableRes.details.length > 0 ? unusedVariableRes.details.map((d)=>d.name) : [];
+    const unconnectedElementsRes = ruleResults.find((r)=>r.ruleName === "UnconnectedElement");
+    const unconnectedElementsReferences = unconnectedElementsRes && unconnectedElementsRes.details && unconnectedElementsRes.details.length > 0 ? unconnectedElementsRes.details.map((d)=>d.name) : [];
+    const nodesToBuild = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>{
+        switch(node.metaType){
+            case "variable":
+                {
+                    const nodeVar = node;
+                    if (!unusedVariableReferences.includes(nodeVar.name)) {
+                        return node;
+                    }
+                    break;
+                }
+            case "node":
+                {
+                    const nodeElement = node;
+                    if (!unconnectedElementsReferences.includes(nodeElement.name)) {
+                        return node;
+                    }
+                    break;
+                }
+            case "metadata":
+            case "resource":
+                return node;
+        }
+    });
+    const xmldata = (0, _BuildFlow.BuildFlow)(nodesToBuild);
+    const newFlow = new _internals.Flow(flow.fsPath, xmldata);
+    return newFlow;
+}

package/main/libs/GetRuleDefinitions.d.ts

@@ -0,0 +1,5 @@
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+import { IRulesConfig } from "../interfaces/IRulesConfig";
+export declare function GetRuleDefinitions(ruleConfig?: Map<string, unknown>, options?: IRulesConfig): IRuleDefinition[];
+export declare function getRules(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[];
+export declare function getBetaRules(): IRuleDefinition[];

package/main/libs/GetRuleDefinitions.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get GetRuleDefinitions () {
+        return GetRuleDefinitions;
+    },
+    get getBetaRules () {
+        return getBetaRules;
+    },
+    get getRules () {
+        return getRules;
+    }
+});
+const _DefaultRuleStore = require("../store/DefaultRuleStore");
+const _DynamicRule = require("./DynamicRule");
+function GetRuleDefinitions(ruleConfig, options) {
+    const selectedRules = [];
+    const includeBeta = (options === null || options === void 0 ? void 0 : options.betamode) === true;
+    if (ruleConfig && ruleConfig instanceof Map) {
+        for (const ruleName of ruleConfig.keys()){
+            let severity = "warning";
+            try {
+                var _ruleConfig_get;
+                const configuredSeverity = (_ruleConfig_get = ruleConfig.get(ruleName)) === null || _ruleConfig_get === void 0 ? void 0 : _ruleConfig_get["severity"];
+                if (configuredSeverity && (configuredSeverity === "error" || configuredSeverity === "warning" || configuredSeverity === "note")) {
+                    severity = configuredSeverity;
+                }
+                const matchedRule = new _DynamicRule.DynamicRule(ruleName);
+                if (configuredSeverity) {
+                    matchedRule.severity = severity;
+                }
+                selectedRules.push(matchedRule);
+            } catch (error) {
+                console.log(error.message);
+            }
+        }
+    } else {
+        // Load all defaults
+        for(const rule in _DefaultRuleStore.DefaultRuleStore){
+            const matchedRule = new _DynamicRule.DynamicRule(rule);
+            selectedRules.push(matchedRule);
+        }
+    }
+    // Append all beta rules if opted in (skip if already included via config/default)
+    if (includeBeta) {
+        for(const betaRuleName in _DefaultRuleStore.BetaRuleStore){
+            if (!selectedRules.some((r)=>r.name === betaRuleName)) {
+                const betaRule = new _DynamicRule.DynamicRule(betaRuleName);
+                selectedRules.push(betaRule);
+            }
+        }
+    }
+    return selectedRules;
+}
+function getRules(ruleNames, options) {
+    if (ruleNames && ruleNames.length > 0) {
+        const ruleSeverityMap = new Map(ruleNames.map((name)=>[
+                name,
+                {
+                    severity: "error"
+                }
+            ]));
+        return GetRuleDefinitions(ruleSeverityMap, options);
+    } else {
+        return GetRuleDefinitions(undefined, options);
+    }
+}
+function getBetaRules() {
+    return getBetaDefinition();
+}
+function getBetaDefinition() {
+    return Object.values(_DefaultRuleStore.BetaRuleStore).map((rule)=>new rule());
+}

package/main/libs/ParseFlows.d.ts

@@ -0,0 +1,2 @@
+import { ParsedFlow } from "../models/ParsedFlow";
+export declare function parse(selectedUris: string[]): Promise<ParsedFlow[]>;

package/main/libs/ParseFlows.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parse", {
+    enumerable: true,
+    get: function() {
+        return parse;
+    }
+});
+const _fastxmlparser = require("fast-xml-parser");
+const _fs = require("fs");
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _Flow = require("../models/Flow");
+const _ParsedFlow = require("../models/ParsedFlow");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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;
+}
+function parse(selectedUris) {
+    return _async_to_generator(function*() {
+        const parseResults = [];
+        const parser = new _fastxmlparser.XMLParser({
+            attributeNamePrefix: "@_",
+            ignoreAttributes: false,
+            // @ts-expect-error type issue
+            ignoreNameSpace: false,
+            parseTagValue: false,
+            textNodeName: "#text"
+        });
+        for (const uri of selectedUris){
+            try {
+                const normalizedURI = _path.normalize(uri);
+                const content = yield _fs.promises.readFile(normalizedURI, "utf8");
+                const parsed = parser.parse(content);
+                const flowObj = parsed.Flow;
+                parseResults.push(new _ParsedFlow.ParsedFlow(uri, new _Flow.Flow(uri, flowObj)));
+            } catch (e) {
+                var _e_message;
+                parseResults.push(new _ParsedFlow.ParsedFlow(uri, undefined, (_e_message = e.message) !== null && _e_message !== void 0 ? _e_message : e.toString()));
+            }
+        }
+        return parseResults;
+    })();
+}

package/main/libs/Scan2.d.ts

@@ -0,0 +1,3 @@
+import { IRulesConfig, ScanResult } from "../internals/internals";
+import { ParsedFlow } from "../models/ParsedFlow";
+export declare function scan2(parsedFlows: ParsedFlow[], ruleOptions?: IRulesConfig): ScanResult[];