@flow-scanner/lightning-flow-scanner-core 6.17.1 → 6.17.3

package/src/main/config/RuleRegistry.ts

@@ -1,188 +0,0 @@
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import { IRuleConfig } from "../interfaces/IRuleConfig";
-import { IRulesConfig } from "../interfaces/IRulesConfig";
-// Import all rules
-import { ActionCallsInLoop } from "../rules/ActionCallsInLoop";
-import { APIVersion } from "../rules/APIVersion";
-import { AutoLayout } from "../rules/AutoLayout";
-import { CopyAPIName } from "../rules/CopyAPIName";
-import { CyclomaticComplexity } from "../rules/CyclomaticComplexity";
-import { DMLStatementInLoop } from "../rules/DMLStatementInLoop";
-import { DuplicateDMLOperation } from "../rules/DuplicateDMLOperation";
-import { FlowDescription } from "../rules/FlowDescription";
-import { FlowName } from "../rules/FlowName";
-import { GetRecordAllFields } from "../rules/GetRecordAllFields";
-import { HardcodedId } from "../rules/HardcodedId";
-import { HardcodedUrl } from "../rules/HardcodedUrl";
-import { HardcodedSecret } from "../rules/HardcodedSecret";
-import { InactiveFlow } from "../rules/InactiveFlow";
-import { MissingFaultPath } from "../rules/MissingFaultPath";
-import { MissingNullHandler } from "../rules/MissingNullHandler";
-import { ProcessBuilder } from "../rules/ProcessBuilder";
-import { RecursiveAfterUpdate } from "../rules/RecursiveAfterUpdate";
-import { SameRecordFieldUpdates } from "../rules/SameRecordFieldUpdates";
-import { SOQLQueryInLoop } from "../rules/SOQLQueryInLoop";
-import { TriggerOrder } from "../rules/TriggerOrder";
-import { UnconnectedElement } from "../rules/UnconnectedElement";
-import { UnsafeRunningContext } from "../rules/UnsafeRunningContext";
-import { UnusedVariable } from "../rules/UnusedVariable";
-import { MissingMetadataDescription } from "../rules/MissingMetadataDescription";
-import { MissingRecordTriggerFilter } from "../rules/MissingRecordTriggerFilter";
-import { TransformInsteadOfLoop } from "../rules/TransformInsteadOfLoop";
-import { RecordIdAsString } from "../rules/RecordIdAsString";
-
-type RuleConstructor = new () => IRuleDefinition;
-
-interface RuleRegistryEntry {
-  ruleId: string;
-  ruleClass: RuleConstructor;
-  legacyName: string;
-  isBeta: boolean;
-}
-
-class RuleRegistry {
-  private rules: Map<string, RuleRegistryEntry> = new Map();
-  private legacyNameMap: Map<string, string> = new Map();
-
-  register(
-    ruleId: string,
-    ruleClass: RuleConstructor,
-    legacyName: string,
-    isBeta: boolean = false
-  ): void {
-    const entry: RuleRegistryEntry = {
-      ruleId,
-      ruleClass,
-      legacyName,
-      isBeta,
-    };
-    this.rules.set(ruleId, entry);
-    this.legacyNameMap.set(legacyName, ruleId);
-  }
-
-  get(idOrLegacyName: string): RuleRegistryEntry | undefined {
-    let entry = this.rules.get(idOrLegacyName);
-    if (!entry) {
-      const ruleId = this.legacyNameMap.get(idOrLegacyName);
-      if (ruleId) {
-        entry = this.rules.get(ruleId);
-      }
-    }
-    return entry;
-  }
-
-  getAllRuleIds(includeBeta: boolean = false): string[] {
-    return Array.from(this.rules.values())
-      .filter(entry => includeBeta || !entry.isBeta)
-      .map(entry => entry.ruleId);
-  }
-
-  has(idOrLegacyName: string): boolean {
-    return this.get(idOrLegacyName) !== undefined;
-  }
-
-  createInstance(idOrLegacyName: string): IRuleDefinition {
-    const entry = this.get(idOrLegacyName);
-    if (!entry) {
-      throw new Error(`Rule not found: ${idOrLegacyName}`);
-    }
-    return new entry.ruleClass();
-  }
-
-  getRules(
-    ruleConfig?: Map<string, unknown>,
-    options?: IRulesConfig
-  ): IRuleDefinition[] {
-    const includeBeta = options?.betaMode === true || options?.betamode === true;
-    const rulesMode = options?.ruleMode || "merged";
-    const selectedRules: IRuleDefinition[] = [];
-
-    if (rulesMode === "isolated" && ruleConfig && ruleConfig.size > 0) {
-      for (const key of ruleConfig.keys()) {
-        const entry = this.get(key);
-        if (!entry) continue;
-
-        const config = ruleConfig.get(key) as IRuleConfig | undefined;
-        if (config?.enabled === false) continue;
-
-        const rule = this.createInstance(entry.ruleId);
-        if (config?.severity) {
-          rule.severity = config.severity;
-        }
-
-        selectedRules.push(rule);
-      }
-      return selectedRules;
-    }
-
-    const allRuleIds = this.getAllRuleIds(includeBeta);
-
-    for (const ruleId of allRuleIds) {
-      const rule = this.createInstance(ruleId);
-
-      const config = (
-        ruleConfig?.get(rule.ruleId) ??
-        ruleConfig?.get(rule.name)
-      ) as IRuleConfig | undefined;
-
-      if (config?.enabled === false) continue;
-      if (config?.severity) {
-        rule.severity = config.severity;
-      }
-
-      selectedRules.push(rule);
-    }
-
-    return selectedRules;
-  }
-
-  getRulesByNames(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[] {
-    if (!ruleNames || ruleNames.length === 0) {
-      return this.getRules(undefined, options);
-    }
-
-    const config = new Map<string, IRuleConfig>();
-    for (const identifier of ruleNames) {
-      const entry = this.get(identifier);
-      if (entry) {
-        config.set(entry.ruleId, { enabled: true });
-      }
-    }
-
-    return this.getRules(config, { ...options, ruleMode: "isolated" });
-  }
-}
-
-const registry = new RuleRegistry();
-
-registry.register("action-call-in-loop", ActionCallsInLoop, "ActionCallsInLoop");
-registry.register("invalid-api-version", APIVersion, "APIVersion");
-registry.register("missing-auto-layout", AutoLayout, "AutoLayout");
-registry.register("unclear-api-naming", CopyAPIName, "CopyAPIName");
-registry.register("excessive-cyclomatic-complexity", CyclomaticComplexity, "CyclomaticComplexity");
-registry.register("dml-in-loop", DMLStatementInLoop, "DMLStatementInLoop");
-registry.register("duplicate-dml", DuplicateDMLOperation, "DuplicateDMLOperation");
-registry.register("missing-flow-description", FlowDescription, "FlowDescription");
-registry.register("invalid-naming-convention", FlowName, "FlowName");
-registry.register("get-record-all-fields", GetRecordAllFields, "GetRecordAllFields");
-registry.register("hardcoded-id", HardcodedId, "HardcodedId");
-registry.register("hardcoded-url", HardcodedUrl, "HardcodedUrl");
-registry.register("inactive-flow", InactiveFlow, "InactiveFlow");
-registry.register("missing-fault-path", MissingFaultPath, "MissingFaultPath");
-registry.register("missing-null-handler", MissingNullHandler, "MissingNullHandler");
-registry.register("process-builder-usage", ProcessBuilder, "ProcessBuilder");
-registry.register("recursive-record-update", RecursiveAfterUpdate, "RecursiveAfterUpdate");
-registry.register("same-record-field-updates", SameRecordFieldUpdates, "SameRecordFieldUpdates");
-registry.register("soql-in-loop", SOQLQueryInLoop, "SOQLQueryInLoop");
-registry.register("unspecified-trigger-order", TriggerOrder, "TriggerOrder");
-registry.register("unreachable-element", UnconnectedElement, "UnconnectedElement");
-registry.register("unsafe-running-context", UnsafeRunningContext, "UnsafeRunningContext");
-registry.register("unused-variable", UnusedVariable, "UnusedVariable");
-
-registry.register("missing-metadata-description", MissingMetadataDescription, "MissingMetadataDescription", true);
-registry.register("missing-record-trigger-filter", MissingRecordTriggerFilter, "MissingFilterRecordTrigger", true);
-registry.register("transform-instead-of-loop", TransformInsteadOfLoop, "TransformInsteadOfLoop", true);
-registry.register("record-id-as-string", RecordIdAsString, "RecordIdAsString", true);
-registry.register("hardcoded-secret", HardcodedSecret, "HardcodedSecret", true);
-
-export const ruleRegistry = registry;

package/src/main/config/VariableIcons.ts

@@ -1,57 +0,0 @@
-/**
- * Icon configuration for flow variable types.
- * Includes icons for variable subtypes and boolean states.
- */
-
-export interface VariableIconConfig {
-  // Variable subtype icons
-  subtypes: {
-    [subtype: string]: string;
-  };
-  // Boolean state icons (for isCollection, isInput, isOutput)
-  boolean: {
-    true: string;
-    false: string;
-  };
-}
-
-/**
- * Default icons using emoji (recommended for modern environments)
- */
-export const DEFAULT_VARIABLE_ICONS: VariableIconConfig = {
-  subtypes: {
-    variables: '\uD83D\uDCCA',        // BAR CHART (data/variable)
-    constants: '\uD83D\uDD12',        // LOCK (constant/immutable)
-    formulas: '\uD83E\uDDEE',         // ABACUS (calculation)
-    choices: '\uD83D\uDCCB',          // CLIPBOARD (picklist/choices)
-    dynamicChoiceSets: '\uD83D\uDD04', // ARROWS (dynamic)
-  },
-  boolean: {
-    true: '\u2705',                   // CHECK MARK
-    false: '\u2B1C',                  // WHITE SQUARE
-  }
-};
-
-/**
- * ASCII fallback icons (for environments without emoji support)
- */
-export const ASCII_VARIABLE_ICONS: VariableIconConfig = {
-  subtypes: {
-    variables: '[V]',
-    constants: '[C]',
-    formulas: '[F]',
-    choices: '[CH]',
-    dynamicChoiceSets: '[D]',
-  },
-  boolean: {
-    true: '[X]',
-    false: '[ ]',
-  }
-};
-
-/**
- * Get default variable icon config
- */
-export function getDefaultVariableIconConfig(): VariableIconConfig {
-  return DEFAULT_VARIABLE_ICONS;
-}

package/src/main/enums/MetadataTypes.ts

@@ -1,6 +0,0 @@
-export enum MetaType {
-  ATTRIBUTE = "attribute",
-  VARIABLE = "variable",
-  RESOURCE = "resource",
-  NODE = "node"
-}

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,6 +0,0 @@
-export interface IRuleConfig {
-  enabled?: boolean;
-  severity?: "error" | "warning" | "note";
-  message?: string; // Custom message to override rule description
-  messageUrl?: string; // Custom URL for documentation (auto-generated if not provided)
-}

package/src/main/interfaces/IRuleDefinition.ts

@@ -1,15 +0,0 @@
-import { Flow, RuleResult } from "../internals/internals";
-
-export interface IRuleDefinition {
-  ruleId: string;
-  description: string;
-  summary: string; // Short summary (5-10 words) shown when no custom message
-  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,17 +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;
-  ruleMode?: "merged" | "isolated"; // Defaults to "merged"
-  ignoreFlows?: string[]; // Flow API names to exclude from scanning
-}

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,14 +0,0 @@
-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;
-}
-
-function convertFlowNodes(obj, nodes, key) {
-  obj[key] = nodes.map((node) => node.element);
-  return obj;
-}

package/src/main/libs/Compiler.ts

@@ -1,53 +0,0 @@
-import { FlowNode } from "../models/FlowNode";
-
-export class Compiler {
-  public visitedElements: Set<string>;
-  constructor() {
-    this.visitedElements = new Set<string>();
-  }
-  traverseFlow(
-    startElementName: string,
-    visitCallback: (element: FlowNode) => void,
-    nodeMap: Map<string, FlowNode>,
-    allConnectors: Map<string, Set<string>>,
-    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 = nodeMap.get(elementName);
-          if (currentElement) {
-            visitCallback(currentElement);
-            this.visitedElements.add(elementName);
-            nextElements.push(...this.findNextElements(elementName, allConnectors, nodeMap, endElementName));
-          }
-        }
-      }
-      if (nextElements.length === 0) {
-        // If no more next elements
-        break; // Terminate the traversal
-      }
-      elementsToVisit = nextElements;
-    }
-  }
-  private findNextElements(
-    elementName: string,
-    allConnectors: Map<string, Set<string>>,
-    nodeMap: Map<string, FlowNode>,
-    endElementName?: string
-  ): string[] {
-    const nextElements: string[] = [];
-    const targets = allConnectors.get(elementName);
-    if (targets) {
-      for (const targetReference of targets) {
-        if (targetReference !== endElementName && nodeMap.has(targetReference)) { // Safety check for existence
-          nextElements.push(targetReference);
-        }
-      }
-    }
-    return nextElements;
-  }
-}

package/src/main/libs/ExportDetails.ts

@@ -1,58 +0,0 @@
-import { FlatViolation } from "../models/FlatViolation";
-import { ScanResult } from "../models/ScanResult";
-
-export function exportDetails(results: ScanResult[], includeDetails = false): FlatViolation[] {
-  return results.flatMap(result => {
-    const flow = result.flow;
-    const flowName = flow.name || flow.label;
-    // Prefer fsPath (resolved absolute path), fallback to uri (input path), or construct from name
-    const flowFile = flow.fsPath 
-      ? flow.fsPath.replace(/\\/g, "/") 
-      : flow.uri 
-        ? flow.uri.replace(/\\/g, "/")
-        : `${flow.name}.flow-meta.xml`;
-    
-    return result.ruleResults
-      .filter(rule => rule.occurs && rule.details?.length)
-      .flatMap(rule => rule.details.map(detail => {
-        // Base violation without details
-        const { details, ...base } = detail;
-        
-        // Build the flat violation with conditionally flattened details
-        const exported: FlatViolation = {
-          ...base,
-          flowFile,
-          flowName,
-          ruleId: rule.ruleId,
-          ruleName: rule.ruleName,
-          severity: rule.severity ?? "warning",
-          message: rule.message || rule.ruleDefinition.description,
-          messageUrl: rule.messageUrl,
-        };
-
-        // Flatten details object into top-level properties if includeDetails is true
-        if (includeDetails && details) {
-          if ('dataType' in details) {
-            exported.dataType = details.dataType as string;
-          }
-          if ('locationX' in details) {
-            exported.locationX = String(details.locationX);
-          }
-          if ('locationY' in details) {
-            exported.locationY = String(details.locationY);
-          }
-          if ('connectsTo' in details) {
-            // Join array into comma-separated string
-            exported.connectsTo = Array.isArray(details.connectsTo) 
-              ? details.connectsTo.join(', ') 
-              : String(details.connectsTo);
-          }
-          if ('expression' in details) {
-            exported.expression = details.expression as string;
-          }
-        }
-
-        return exported;
-      }));
-  });
-}

package/src/main/libs/ExportDiagram.ts

@@ -1,83 +0,0 @@
-import { Flow } from "../models/Flow";
-import { ParsedFlow } from "../models/ParsedFlow";
-
-export interface DiagramOptions {
-  includeDetails?: boolean;
-  includeMarkdownDocs?: boolean;
-  collapsedDetails?: boolean;
-}
-
-/**
- * Generate Markdown documentation for parsed flows, including Mermaid diagrams for valid flows.
- * 
- * This function can be chained after parse() to generate documentation.
- * It filters out errored parses and only documents valid flows.
- * 
- * @param parsedFlows Array of ParsedFlow objects from parse()
- * @param options Visualization options for Mermaid diagrams
- * 
- * @returns Markdown string with documentation
- * 
- * @example
- * ```typescript
- * // Node.js usage
- * import { parse, exportFlowMarkdown } from "@flow-scanner/lightning-flow-scanner-core";
- * import fs from "fs/promises";
- * 
- * const parsed = await parse(["flows/*.xml"]);
- * const md = exportFlowMarkdown(parsed, {
- *   includeDetails: true,
- *   includeMarkdownDocs: true,
- *   collapsedDetails: true
- * });
- * await fs.writeFile("flow-doc.md", md);
- * ```
- * 
- * @example
- * ```typescript
- * // Chained (async/await)
- * const md = await parse(["flows/*.xml"]).then(parsed => 
- *   exportFlowMarkdown(parsed, { includeDetails: true })
- * );
- * ```
- */
-export function exportDiagram(
-  parsedFlows: ParsedFlow[],
-  options: DiagramOptions = {
-    includeDetails: true,
-    includeMarkdownDocs: true,
-    collapsedDetails: true
-  }
-): string {
-  const validFlows = parsedFlows.filter(p => p.flow).map(p => p.flow!);
-  
-  let markdown = "# Flow Documentation\n\n";
-  
-  if (validFlows.length === 0) {
-    markdown += "No valid flows found.\n\n";
-  }
-  
-  for (const flow of validFlows) {
-    markdown += `## ${flow.name}\n\n`;
-    
-    const vizOptions = {
-      includeDetails: options.includeDetails,
-      includeMarkdownDocs: options.includeMarkdownDocs,
-      collapsedDetails: options.collapsedDetails
-    };
-    
-    markdown += flow.visualize("mermaid", vizOptions) + "\n\n";
-  }
-  
-  // Optionally add errors section if any
-  const errors = parsedFlows.filter(p => p.errorMessage);
-  if (errors.length > 0) {
-    markdown += "## Parse Errors\n\n";
-    for (const err of errors) {
-      markdown += `- ${err.uri}: ${err.errorMessage}\n`;
-    }
-    markdown += "\n";
-  }
-  
-  return markdown;
-}

package/src/main/libs/ExportSarif.ts

@@ -1,92 +0,0 @@
-import { Flow } from "../models/Flow";
-import { ScanResult } from "../models/ScanResult";
-import { Violation } from "../models/Violation";
-
-export function exportSarif(results: ScanResult[]): string {
-  const runs = results.map((result) => {
-    const flow = result.flow;
-    const uri = getUri(flow);
-    return {
-      artifacts: [{ location: { uri }, sourceLanguage: "xml" }],
-      results: result.ruleResults
-        .filter(r => r.occurs)
-        .flatMap(r => r.details.map(d => ({
-          level: mapSeverity(r.severity),
-          locations: [{
-            physicalLocation: {
-              artifactLocation: { index: 0, uri },
-              region: mapRegion(d)
-            },
-          }],
-          message: {
-            text: r.errorMessage || (r.message || r.ruleDefinition.description
-              ? `${r.message || r.ruleDefinition.description} (${d.name})`
-              : `${r.ruleId} in ${d.name}`)
-          },
-          properties: {
-            element: d.name,
-            flow: flow.name,
-            type: d.type,
-            ...d.details,
-          },
-          ruleId: r.ruleId,
-        }))),
-      tool: {
-        driver: {
-          informationUri: "https://github.com/Flow-Scanner/lightning-flow-scanner",
-          name: "Lightning Flow Scanner",
-          rules: result.ruleResults
-            .filter(r => r.occurs)
-            .map(r => ({
-              defaultConfiguration: { level: mapSeverity(r.severity) },
-              fullDescription: { text: r.message || r.ruleDefinition.description || "" },
-              id: r.ruleId,
-              shortDescription: { text: r.message || r.ruleDefinition.description || r.ruleId },
-            })),
-          version: "1.0.0",
-        },
-      },
-    };
-  });
-  return JSON.stringify({
-    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
-    runs,
-    version: "2.1.0",
-  }, null, 2);
-}
-
-function getUri(flow: Flow): string {
-  // Prefer uri (works in both browser and Node)
-  if (flow.uri) {
-    return flow.uri.replace(/\\/g, "/");
-  }
-  
-  // Node only: fsPath is only set in Node environments
-  if (flow.fsPath) {
-    const match = flow.fsPath.match(/(?:force-app|src)\/.+$/);
-    if (match) {
-      return match[0].replace(/\\/g, "/");
-    }
-    return flow.fsPath.replace(/\\/g, "/");
-  }
-  
-  return `flows/${flow.name}.flow-meta.xml`;
-}
-
-function mapRegion(detail: Violation): any {
-  // Use pre-enriched line/column from Violation (added by enrichViolationsWithLineNumbers)
-  // Fallback if somehow missing (e.g., unenriched legacy data)
-  return {
-    startColumn: detail.columnNumber ?? 1,
-    startLine: detail.lineNumber ?? 1,
-  };
-}
-
-function mapSeverity(sev: string): "error" | "note" | "warning" {
-  switch (sev?.toLowerCase()) {
-    case "info":
-    case "note": return "note";
-    case "warning": return "warning";
-    default: return "warning";
-  }
-}