@flow-scanner/lightning-flow-scanner-core 6.6.4 → 6.6.5

package/eslint.config.mjs

@@ -1,36 +0,0 @@
-import deMorgan from "eslint-plugin-de-morgan";
-import github from "eslint-plugin-github";
-import pluginJest from "eslint-plugin-jest";
-import perfectionist from "eslint-plugin-perfectionist";
-import sonarjs from "eslint-plugin-sonarjs";
-import globals from "globals";
-import tseslint from "typescript-eslint";
-
-export default [
-  { languageOptions: { globals: globals.browser } },
-  ...tseslint.configs.recommended,
-  {
-    files: ["tests/*.test.ts"],
-    languageOptions: {
-      globals: pluginJest.environments.globals.globals,
-    },
-    plugins: { jest: pluginJest },
-    rules: {
-      "jest/no-alias-methods": "error",
-      "jest/no-disabled-tests": "warn",
-      "jest/no-focused-tests": "error",
-      "jest/no-identical-title": "error",
-      "jest/prefer-to-have-length": "warn",
-      "jest/valid-expect": "error",
-    },
-  },
-  {
-    ignores: ["jest.config.ts", "assets/example-flows/**"],
-  },
-  perfectionist.configs["recommended-alphabetical"],
-  perfectionist.configs["recommended-line-length"],
-  perfectionist.configs["recommended-natural"],
-  sonarjs.configs.recommended,
-  deMorgan.configs.recommended,
-  ...github.getFlatConfigs().typescript,
-];

package/jest.config.cjs

@@ -1,32 +0,0 @@
-module.exports = {
-  automock: false,
-  clearMocks: true,
-  collectCoverage: true,
-  coverageDirectory: "coverage",
-  coverageProvider: "v8",
-  coverageReporters: ["json", "text", "lcov"],
-  modulePathIgnorePatterns: ["./jest.config.cjs", "./out/"],
-  setupFilesAfterEnv: ["<rootDir>/jest.env-setup.js"],
-  testEnvironment: "node",
-  testPathIgnorePatterns: ["/node_modules/"],
-  transform: {
-    "^.+\\.(t|j)sx?$": [
-      "@swc-node/jest",
-      {
-        module: "commonjs",
-        swc: {
-          jsc: {
-            target: "es2020",
-            parser: {
-              syntax: "typescript",
-              tsx: false,
-            },
-          },
-          sourceMaps: "inline",
-          minify: false,
-        },
-      },
-    ],
-  },
-  transformIgnorePatterns: ["/node_modules/", "\\.pnp\\.[^\\/]+$"],
-};

package/jest.env-setup.js

@@ -1,101 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-module.exports = () => {
-  if (!process.env.UMD_PATH) {
-    console.log("UMD Setup: No UMD_PATH—skipping (Node-only mode)");
-    return;
-  }
-
-  const umdFilePath = path.resolve(process.env.UMD_PATH);
-
-  if (!fs.existsSync(umdFilePath)) {
-    console.warn("UMD Setup: File not found at", umdFilePath, "—skipping.");
-    return;
-  }
-
-  let umdCode = fs.readFileSync(umdFilePath, "utf8");
-  const fastXmlParser = require("fast-xml-parser");
-
-  // Vite UMD pattern: (function(global, factory) { ... })(this, function(exports, dependency) { ... });
-  // We need to extract and execute the factory function
-
-  // Try to match Vite's UMD pattern more flexibly
-  const viteUmdMatch = umdCode.match(
-    /\(function\s*\([^,]+,\s*(\w+)\)\s*\{[\s\S]*?\}\)\s*\(this,\s*function\s*\((\w+)(?:,\s*(\w+))?\)\s*\{([\s\S]+)\}\s*\)\s*;?\s*$/
-  );
-
-  if (viteUmdMatch) {
-    const factoryBody = viteUmdMatch[4];
-    const exportsParam = viteUmdMatch[2];
-    const depParam = viteUmdMatch[3];
-
-    try {
-      // Create the factory function with proper parameters
-      const factoryFn = depParam
-        ? new Function(exportsParam, depParam, factoryBody)
-        : new Function(exportsParam, factoryBody);
-
-      // Create exports object and invoke factory
-      const exports = {};
-      if (depParam) {
-        factoryFn(exports, fastXmlParser);
-      } else {
-        factoryFn(exports);
-      }
-
-      // Assign to global
-      global.lightningflowscanner = exports;
-
-      if (Object.keys(exports).length === 0) {
-        console.error("UMD Setup: WARNING - exports object is empty!");
-      }
-    } catch (e) {
-      console.error("UMD Factory error:", e.message);
-      console.error("Stack:", e.stack);
-    }
-  } else {
-    // Fallback: Try direct execution approach
-
-    try {
-      // Create a mock global/window context
-      const mockGlobal = {};
-      const mockFactory = new Function(
-        "global",
-        "factory",
-        `
-        return (function(root, factoryFn) {
-          if (typeof exports === 'object' && typeof module !== 'undefined') {
-            factoryFn(exports, require('fast-xml-parser'));
-          } else {
-            factoryFn((root.lightningflowscanner = {}), root.fastXmlParser);
-          }
-        })(global, factory);
-      `
-      );
-
-      // Execute in controlled context
-      const vm = require("vm");
-      const sandbox = {
-        exports: {},
-        require: (id) => (id === "fast-xml-parser" ? fastXmlParser : require(id)),
-        module: { exports: {} },
-        console: console,
-      };
-
-      vm.runInNewContext(umdCode, sandbox);
-
-      // Check what got exported
-      const exports = sandbox.exports.default || sandbox.exports || sandbox.module.exports;
-
-      if (exports && Object.keys(exports).length > 0) {
-        global.lightningflowscanner = exports;
-      } else {
-        console.error("UMD Setup: Direct execution failed - no exports found");
-      }
-    } catch (e) {
-      console.error("UMD Direct execution error:", e.message);
-      console.error("Stack:", e.stack.slice(0, 400));
-    }
-  }
-};

package/lint-staged.config.mjs

@@ -1,8 +0,0 @@
-import micromatch from "micromatch";
-
-const isNotExampleFlows = (files) => micromatch.not(files, ["assets/example-flows/**"]);
-
-export default {
-  "**/*.{js,json,md,xml,yaml,yml}": (files) =>
-    isNotExampleFlows(files).map((f) => `prettier --write "${f}"`),
-};

package/prettier.config.mjs

@@ -1,5 +0,0 @@
-export default {
-  printWidth: 100,
-  tabWidth: 2,
-  trailingComma: "es5",
-};

package/src/index.ts

@@ -1,44 +0,0 @@
-import type { IRuleDefinition } from "./main/interfaces/IRuleDefinition";
-import type { IRulesConfig } from "./main/interfaces/IRulesConfig";
-import type { FlatViolation } from "./main/models/FlatViolation";
-
-import { Compiler } from "./main/libs/Compiler";
-import { exportDetails } from "./main/libs/exportAsDetails";
-import { exportSarif } from "./main/libs/exportAsSarif";
-import { fix } from "./main/libs/FixFlows";
-import { getRules } from "./main/libs/GetRuleDefinitions";
-import { parse } from "./main/libs/ParseFlows";
-import { scan } from "./main/libs/ScanFlows";
-import { Flow } from "./main/models/Flow";
-import { FlowAttribute } from "./main/models/FlowAttribute";
-import { FlowElement } from "./main/models/FlowElement";
-import { FlowNode } from "./main/models/FlowNode";
-import { FlowResource } from "./main/models/FlowResource";
-import { FlowType } from "./main/models/FlowType";
-import { FlowVariable } from "./main/models/FlowVariable";
-import { ParsedFlow } from "./main/models/ParsedFlow";
-import { RuleResult } from "./main/models/RuleResult";
-import { ScanResult } from "./main/models/ScanResult";
-import { Violation } from "./main/models/Violation";
-
-export {
-  Compiler,
-  exportDetails,
-  exportSarif,
-  fix,
-  Flow,
-  FlowAttribute,
-  FlowElement,
-  FlowNode,
-  FlowResource,
-  FlowType,
-  FlowVariable,
-  getRules,
-  parse,
-  ParsedFlow,
-  Violation,
-  RuleResult,
-  scan,
-  ScanResult,
-};
-export type { FlatViolation, IRuleDefinition, IRulesConfig };

package/src/main/interfaces/IExceptions.ts

@@ -1,6 +0,0 @@
-export interface IExceptions {
-  [exceptionName: string]: {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    [property: string]: any[];
-  };
-}

package/src/main/interfaces/IRuleConfig.ts

@@ -1,3 +0,0 @@
-export interface IRuleConfig {
-  severity?: string;
-}

package/src/main/interfaces/IRuleDefinition.ts

@@ -1,12 +0,0 @@
-import { Flow, RuleResult } from "../internals/internals";
-export interface IRuleDefinition {
-  description: string;
-  docRefs: Array<{ label: string; path: string }>;
-  execute(flow: Flow, options?: object, suppressions?: string[]): RuleResult;
-  isConfigurable: boolean;
-  label: string;
-  name: string;
-  severity?: string;
-  supportedTypes: string[];
-  uri?: string;
-}

package/src/main/interfaces/IRuleOptions.ts

@@ -1,5 +0,0 @@
-import { IRuleConfig } from "./IRuleConfig";
-
-export interface IRuleOptions {
-  [ruleName: string]: IRuleConfig;
-}

package/src/main/interfaces/IRulesConfig.ts

@@ -1,15 +0,0 @@
-import { IExceptions } from "./IExceptions";
-import { IRuleOptions } from "./IRuleOptions";
-
-export enum DetailLevel {
-  ENRICHED = 'enriched',
-  SIMPLE = 'simple'
-}
-
-export interface IRulesConfig {
-  betaMode?: boolean;  // Toggles beta rules; defaults to false
-  betamode?: boolean;  // Use betaMode instead; to be removed
-  detailLevel?: 'enriched' | 'simple' | DetailLevel;
-  exceptions?: IExceptions;
-  rules?: IRuleOptions; 
-}

package/src/main/internals/internals.ts

@@ -1,35 +0,0 @@
-import type { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import type { IRulesConfig } from "../interfaces/IRulesConfig";
-
-import { Compiler } from "../libs/Compiler";
-import { FlatViolation } from "../models/FlatViolation";
-import { Flow } from "../models/Flow";
-import { FlowAttribute } from "../models/FlowAttribute";
-import { FlowElement } from "../models/FlowElement";
-import { FlowNode } from "../models/FlowNode";
-import { FlowResource } from "../models/FlowResource";
-import { FlowType } from "../models/FlowType";
-import { FlowVariable } from "../models/FlowVariable";
-import { ParsedFlow } from "../models/ParsedFlow";
-import { RuleCommon } from "../models/RuleCommon";
-import { RuleResult } from "../models/RuleResult";
-import { ScanResult } from "../models/ScanResult";
-import { Violation } from "../models/Violation";
-
-// Used to prevent circular dependencies in Common JS
-export {
-  FlowAttribute,
-  FlowElement,
-  FlowNode,
-  FlowType,
-  FlowVariable,
-  FlowResource,
-  Flow,
-  Compiler,
-  ScanResult,
-  RuleResult,
-  Violation,
-  RuleCommon,
-  ParsedFlow,
-};
-export type { IRuleDefinition, IRulesConfig, FlatViolation };

package/src/main/libs/BuildFlow.ts

@@ -1,11 +0,0 @@
-import { convertFlowNodes } from "./ConvertFlowNodes";
-
-export function BuildFlow(nodesToMerge) {
-  let res = {};
-  for (const nodeToMerge of nodesToMerge) {
-    const subtype = nodeToMerge.subtype;
-    const nodesOfType = nodesToMerge.filter((node) => subtype === node.subtype);
-    res = convertFlowNodes(res, nodesOfType, subtype);
-  }
-  return res;
-}

package/src/main/libs/Compiler.ts

@@ -1,69 +0,0 @@
-import { Flow } from "../models/Flow";
-import { FlowNode } from "../models/FlowNode";
-
-export class Compiler {
-  public visitedElements: Set<string>;
-
-  constructor() {
-    this.visitedElements = new Set<string>();
-  }
-
-  traverseFlow(
-    flow: Flow,
-    startElementName: string,
-    visitCallback: (element: FlowNode) => void,
-    endElementName?: string
-  ) {
-    // Iterative Deepening Depth-First Search (IDDFS)
-    let elementsToVisit = [startElementName];
-
-    while (elementsToVisit.length > 0) {
-      const nextElements: string[] = [];
-
-      for (const elementName of elementsToVisit) {
-        if (!this.visitedElements.has(elementName)) {
-          const currentElement = flow.elements?.find(
-            (element) => element.name === elementName
-          ) as FlowNode;
-          if (currentElement) {
-            visitCallback(currentElement);
-            this.visitedElements.add(elementName);
-            nextElements.push(...this.findNextElements(flow, currentElement, endElementName));
-          }
-        }
-      }
-
-      if (nextElements.length === 0) {
-        // If no more next elements
-        break; // Terminate the traversal
-      }
-
-      elementsToVisit = nextElements;
-    }
-  }
-
-  private findNextElements(
-    flow: Flow,
-    currentElement: FlowNode,
-    endElementName?: string
-  ): string[] {
-    const nextElements: string[] = [];
-
-    if (!currentElement.connectors || currentElement.connectors.length === 0) {
-      return nextElements;
-    }
-
-    for (const connector of currentElement.connectors) {
-      const targetReference =
-        connector?.connectorTargetReference?.targetReference ?? connector.reference;
-      // Check if the reference exists in the flow elements
-      const nextElement = flow.elements?.find(
-        (element) => element.metaType === "node" && element.name === targetReference
-      );
-      if (nextElement && nextElement.metaType === "node" && nextElement.name !== endElementName) {
-        nextElements.push(nextElement!.name as string);
-      }
-    }
-    return nextElements;
-  }
-}

package/src/main/libs/ConvertFlowNodes.ts

@@ -1,4 +0,0 @@
-export function convertFlowNodes(obj, nodes, key) {
-  obj[key] = nodes.map((node) => node.element);
-  return obj;
-}

package/src/main/libs/DynamicRule.ts

@@ -1,11 +0,0 @@
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import { BetaRuleStore, DefaultRuleStore } from "../store/DefaultRuleStore";
-
-export class DynamicRule<T extends IRuleDefinition> {
-  constructor(className: string, betaMode = false) {
-    if (betaMode && BetaRuleStore.hasOwnProperty(className)) {
-      return new BetaRuleStore[className]() as T;
-    }
-    return new DefaultRuleStore[className]() as T;
-  }
-}

package/src/main/libs/FixFlows.ts

@@ -1,61 +0,0 @@
-import * as core from "../internals/internals";
-import { BuildFlow } from "./BuildFlow";
-
-export function fix(results: core.ScanResult[]): core.ScanResult[] {
-  const newResults: core.ScanResult[] = [];
-
-  for (const result of results) {
-    if (!result.ruleResults || result.ruleResults.length === 0) continue;
-
-    const fixables: core.RuleResult[] = result.ruleResults.filter(
-      (r) =>
-        (r.ruleName === "UnusedVariable" && r.occurs) ||
-        (r.ruleName === "UnconnectedElement" && r.occurs)
-    );
-
-    if (fixables.length === 0) continue;
-
-    const newFlow = FixFlows(result.flow, fixables);
-
-    const hasRemainingElements = newFlow.elements && newFlow.elements.length > 0;
-    if (hasRemainingElements) {
-      result.flow = newFlow;
-      newResults.push(result);
-    }
-  }
-
-  return newResults;
-}
-
-export function FixFlows(flow: core.Flow, ruleResults: core.RuleResult[]): core.Flow {
-  const unusedVariableRes = ruleResults.find((r) => r.ruleName === "UnusedVariable");
-  const unusedVariableNames = new Set(
-    unusedVariableRes?.details?.map((d) => d.name) ?? []
-  );
-
-  const unconnectedElementsRes = ruleResults.find((r) => r.ruleName === "UnconnectedElement");
-  const unconnectedElementNames = new Set(
-    unconnectedElementsRes?.details?.map((d) => d.name) ?? []
-  );
-
-  const nodesToKeep = flow.elements?.filter((node) => {
-    switch (node.metaType) {
-      case "metadata":
-      case "resource":
-        return true;
-      case "node": {
-        const nodeElement = node as core.FlowNode;
-        return !unconnectedElementNames.has(nodeElement.name);
-      }
-      case "variable": {
-        const nodeVar = node as core.FlowVariable;
-        return !unusedVariableNames.has(nodeVar.name);
-      }
-      default:
-        return false;
-    }
-  }) ?? [];
-
-  const xmldata = BuildFlow(nodesToKeep);
-  return new core.Flow(flow.fsPath, xmldata);
-}

package/src/main/libs/GetRuleDefinitions.ts

@@ -1,65 +0,0 @@
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import { IRulesConfig } from "../interfaces/IRulesConfig";
-import { BetaRuleStore, DefaultRuleStore } from "../store/DefaultRuleStore";
-import { DynamicRule } from "./DynamicRule";
-
-export function GetRuleDefinitions(
-  ruleConfig?: Map<string, unknown>,
-  options?: IRulesConfig
-): IRuleDefinition[] {
-  const selectedRules: IRuleDefinition[] = [];
-  const includeBeta = options?.betaMode === true || options?.betamode === true;
-
-  if (ruleConfig && ruleConfig instanceof Map) {
-    for (const ruleName of ruleConfig.keys()) {
-      let severity = "warning";
-      try {
-        const configuredSeverity = ruleConfig.get(ruleName)?.["severity"];
-        if (
-          configuredSeverity &&
-          (configuredSeverity === "error" ||
-           configuredSeverity === "warning" ||
-           configuredSeverity === "note")
-        ) {
-          severity = configuredSeverity;
-        }
-
-        // Pass betaMode to DynamicRule
-        const matchedRule = new DynamicRule(ruleName, includeBeta) as IRuleDefinition;
-        if (configuredSeverity) matchedRule.severity = severity;
-        selectedRules.push(matchedRule);
-
-      } catch (error) {
-        console.log(error.message);
-      }
-    }
-  } else {
-    // Load all defaults
-    for (const rule in DefaultRuleStore) {
-      const matchedRule = new DynamicRule(rule, includeBeta) as IRuleDefinition;
-      selectedRules.push(matchedRule);
-    }
-  }
-
-  // Optionally add beta-only rules that are not in defaults
-  if (includeBeta) {
-    for (const betaRuleName in BetaRuleStore) {
-      if (!selectedRules.some(r => r.name === betaRuleName)) {
-        const betaRule = new DynamicRule(betaRuleName, true) as IRuleDefinition;
-        selectedRules.push(betaRule);
-      }
-    }
-  }
-
-  return selectedRules;
-}
-
-export function getRules(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[] {
-  if (ruleNames && ruleNames.length > 0) {
-    const ruleSeverityMap = new Map<string, { severity: string }>(
-      ruleNames.map(name => [name, { severity: "error" }])
-    );
-    return GetRuleDefinitions(ruleSeverityMap, options);
-  }
-  return GetRuleDefinitions(undefined, options);
-}

package/src/main/libs/ParseFlows.ts

@@ -1,34 +0,0 @@
-import { XMLParser } from "fast-xml-parser";
-import { promises as fs } from "fs";
-import * as p from "path";
-
-import { Flow } from "../models/Flow";
-import { ParsedFlow } from "../models/ParsedFlow";
-
-
-export async function parse(selectedUris: string[]): Promise<ParsedFlow[]> {
-  const parseResults: ParsedFlow[] = [];
-  const parser = new XMLParser({
-    attributeNamePrefix: "@_",
-    ignoreAttributes: false,
-    // @ts-expect-error type issue
-    ignoreNameSpace: false,
-    parseTagValue: false,
-    textNodeName: "#text"
-  });
-
-  for (const uri of selectedUris) {
-    try {
-      const normalizedURI = p.normalize(uri);
-      const content = await fs.readFile(normalizedURI, "utf8");
-      const parsed = parser.parse(content);
-      const flowObj = parsed.Flow;
-      parseResults.push(new ParsedFlow(uri, new Flow(uri, flowObj)));
-    } catch (e: any) {
-      parseResults.push(
-        new ParsedFlow(uri, undefined, e.message ?? e.toString())
-      );
-    }
-  }
-  return parseResults;
-}