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

package/src/main/models/RuleCommon.ts

@@ -1,120 +0,0 @@
-import { RuleInfo } from "./RuleInfo";
-import * as core from "../internals/internals";
-
-export abstract class RuleCommon {
-  public category?: 'problem' | 'suggestion' | 'layout';
-  public description: string;
-  public summary: string;
-  public docRefs: Array<{ label: string; path: string }> = [];
-  public isConfigurable: boolean;
-  public label: string;
-  public name: string;
-  public severity?: string;
-  public supportedTypes: string[];
-  public uri?: string;
-  public readonly ruleId: string;
-
-  constructor(info: RuleInfo, optional?: { severity?: string }) {
-    this.category = info.category;
-    this.ruleId = info.ruleId;
-    this.name = info.name;
-    this.supportedTypes = info.supportedTypes;
-    this.label = info.label;
-    this.description = info.description;
-    this.summary = info.summary;
-    this.uri = `https://github.com/Lightning-Flow-Scanner/lightning-flow-scanner/tree/main/src/main/rules/${info.name}.ts`;
-    this.docRefs = info.docRefs;
-
-    const checkImpl = (this as any).check;
-    if (typeof checkImpl === "function") {
-      const source = checkImpl.toString();
-      this.isConfigurable = /options[.\?]/.test(source);
-    } else {
-      this.isConfigurable = false;
-    }
-
-    this.severity = optional?.severity ?? "warning";
-  }
-
-  public execute(
-    flow: core.Flow,
-    options?: object,
-    suppressions: string[] = []
-  ): core.RuleResult {
-    // Wildcard suppression disables entire rule
-    if (suppressions.includes("*")) {
-      return new core.RuleResult(this as any, []);
-    }
-    
-    if (suppressions.includes(this.ruleId) || suppressions.includes(this.name)) {
-      return new core.RuleResult(this as any, []);
-    }
-    
-    const suppSet = new Set(suppressions);
-    let violations = this.check(flow, options, suppSet);
-    violations = violations.filter(v => !suppSet.has(v.name));
-    return new core.RuleResult(this as any, violations);
-  }
-
-  protected abstract check(
-    flow: core.Flow,
-    options: object | undefined,
-    suppressions: Set<string>
-  ): core.Violation[];
-
-  protected isSuppressed(name: string, suppressions: Set<string>): boolean {
-    return suppressions.has(name);
-  }
-
-  /**
-   * Get the start node (the special <start> element).
-   * This is now stored separately in flow.startNode, not in flow.elements.
-   * 
-   * @param flow - The Flow instance
-   * @returns The start FlowNode or undefined if not found
-   */
-  protected getStartNode(flow: core.Flow): core.FlowNode | undefined {
-    return flow.startNode;
-  }
-
-  /**
-   * Get the reference name of the first actual element (what the flow starts at).
-   * This is the element that comes AFTER the start node.
-   * 
-   * @param flow - The Flow instance
-   * @returns The start reference name or undefined
-   */
-  protected getStartReference(flow: core.Flow): string | undefined {
-    return flow.startReference || undefined;
-  }
-
-  /**
-   * Find the INDEX of the first actual element in a FlowNode array.
-   * Useful for rules that need to iterate by index.
-   * 
-   * @param flow - The Flow instance
-   * @param flowElements - Array of FlowNodes (typically from flow.elements)
-   * @returns The index of the starting element, or -1 if not found
-   */
-  protected findStartIndex(flow: core.Flow, flowElements: core.FlowNode[]): number {
-    const startRef = this.getStartReference(flow);
-    if (!startRef) {
-      return -1;
-    }
-    return flowElements.findIndex(n => n.name === startRef);
-  }
-
-  /**
-   * Safely get a property from the start element.
-   * 
-   * @param flow - The Flow instance
-   * @param propertyName - The property to retrieve (e.g., 'triggerType', 'object')
-   * @returns The property value or undefined
-   */
-  protected getStartProperty(flow: core.Flow, propertyName: string): any {
-    if (flow.startNode?.element) {
-      return (flow.startNode.element as Record<string, unknown>)?.[propertyName];
-    }
-    return undefined;
-  }
-}

package/src/main/models/RuleInfo.ts

@@ -1,54 +0,0 @@
-export type RuleDefinitionExpression = {
-  options?: {
-    expression?: unknown;
-  };
-};
-
-/**
- * Represents a rule metadata; this contains properties to describe the rule
- */
-export class RuleInfo {
-  /**
-   * A human-readable description of the rule.
-   */
-  public description: string;
-
-  /**
-   * A short summary (5-10 words) used when no custom message is provided.
-   */
-  public summary: string;
-
-  /**
-   * An array of documentation references related to the rule.
-   */
-  public docRefs: Array<{ label: string; path: string }>;
-
-  /**
-   * The display label for the rule.
-   * This property is being displayed on sf cli and on vsce
-   */
-  public label: string;
-
-  /**
-   * The category for the rule.
-   * 'problem' | 'suggestion' | 'layout'
-   */
-  public category: 'problem' | 'suggestion' | 'layout';
-
-  /**
-   * Stable public identifier used for config, suppression, and reporting.
-   */
-  public ruleId: string;
-
-  /**
-   * Legacy rule name (class-based identifier).
-   * Kept for backward compatibility.
-   */
-  public name: string;
-
-  /**
-   * The types supported by this rule (e.g., Flow, Process).
-   * Use defined types in @see FlowType
-   */
-  public supportedTypes: string[];
-}

package/src/main/models/RuleResult.ts

@@ -1,29 +0,0 @@
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import { Violation } from "./Violation";
-
-export class RuleResult {
-  public occurs: boolean;
-  public ruleName: string;
-  public ruleId: string;
-  public ruleDefinition: IRuleDefinition;
-  public severity: string;
-  public details: Violation[] = [];
-  public errorMessage: string;
-  public message?: string; // Custom message that overrides the default rule description
-  public messageUrl?: string; // URL to custom documentation (fallback to rule docs if not provided)
-
-  constructor(info: IRuleDefinition, details: Violation[], errorMessage?: string) {
-    this.ruleDefinition = info;
-    this.ruleName = info.name;
-    this.ruleId = info.ruleId;
-    this.severity = info.severity ? info.severity : "warning";
-    this.occurs = false;
-    this.details = details;
-    if (details.length > 0) {
-      this.occurs = true;
-    }
-    if (errorMessage) {
-      this.errorMessage = errorMessage;
-    }
-  }
-}

package/src/main/models/ScanResult.ts

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

package/src/main/models/Violation.ts

@@ -1,78 +0,0 @@
-import { MetaType } from "../enums/MetadataTypes";
-import { Flow } from "./Flow";
-import { FlowAttribute } from "./FlowAttribute";
-import { FlowElement } from "./FlowElement";
-import { FlowNode } from "./FlowNode";
-import { FlowVariable } from "./FlowVariable";
-
-export class Violation {
-  public columnNumber: number;  // Mandatory post-enrich; defaults to 1 if not found
-  public details?: object;      // Optional; only populated for rule-specific needs
-  public lineNumber: number;    // Mandatory post-enrich; defaults to 1 if not found
-  public metaType: string;
-  public name: string;
-  public type: string;
-
-  constructor(violation: FlowElement) {
-    this.name = violation.name;
-    this.metaType = violation.metaType;
-    this.type = violation.subtype;
-    this.lineNumber = 1;         // Default; will be overwritten by enrich if found
-    this.columnNumber = 1;       // Default; will be overwritten by enrich if found
-
-    // Conditionally populate details only if needed (e.g., via config flag later)
-    if (violation.metaType === MetaType.VARIABLE) {
-      const element = violation as FlowVariable;
-      this.details = { dataType: element.dataType };
-    } else if (violation.metaType === MetaType.NODE) {
-      const element = violation as FlowNode;
-      this.details = {
-        connectsTo: element.connectors?.map((connector) => connector.reference),
-        locationX: element.locationX,
-        locationY: element.locationY,
-      };
-    } else if (violation.metaType === MetaType.ATTRIBUTE) {
-      const element = violation as FlowAttribute;
-      this.details = { expression: element.expression };
-    }
-    // For other metaTypes or if details disabled, remains undefined
-  }
-}
-
-export function enrichViolationsWithLineNumbers(
-  violations: Violation[],
-  flowXml: string
-): void {
-  if (!flowXml || violations.length === 0) return;
-  const lines = flowXml.split("\n");
-  // Flow-level XML tags (same as Flow.flowMetadata)
-  const flowLevelTags = Flow.ATTRIBUTE_TAGS;
-  for (const violation of violations) {
-    // For flow elements (nodes, variables, resources), search by <name> tag
-    if (violation.metaType !== MetaType.ATTRIBUTE) {
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].includes(`<name>${violation.name}</name>`)) {
-          violation.lineNumber = i + 1;
-          violation.columnNumber = lines[i].indexOf(violation.name) + 1;
-          break;
-        }
-      }
-    }
-    // For flow-level attributes, search by the XML tag if it exists
-    if (violation.metaType === MetaType.ATTRIBUTE) {
-      const tagName = violation.type;
-     
-      // Only search if it's an actual XML tag (type assertion for literal check)
-      if (flowLevelTags.includes(tagName as any)) {
-        for (let i = 0; i < lines.length; i++) {
-          if (lines[i].includes(`<${tagName}>`)) {
-            violation.lineNumber = i + 1;
-            violation.columnNumber = lines[i].indexOf(`<${tagName}>`) + 1;
-            break;
-          }
-        }
-      }
-      // If not found, stays at default (1,1)
-    }
-  }
-}

package/src/main/rules/APIVersion.ts

@@ -1,93 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class APIVersion extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "invalid-api-version",
-      category: "suggestion",
-      name: "APIVersion",
-      label: "Invalid API Version",
-      description: "Flows running on outdated API versions may behave inconsistently when newer platform features or components are used. From API version 50.0 onward, the API Version attribute explicitly controls Flow runtime behavior. Keeping Flows aligned with a supported API version helps prevent compatibility issues and ensures predictable execution.",
-      summary: "Outdated API versions risk compatibility issues",
-      supportedTypes: core.FlowType.allTypes(),
-      docRefs: [],
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    options: { expression?: string } | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    let flowAPIVersionNumber: number | null = null;
-    if (flow.xmldata.apiVersion) {
-      flowAPIVersionNumber = +flow.xmldata.apiVersion;
-    }
-
-    // Custom logic
-    if (options?.expression) {
-      // No API version with custom expression
-      if (!flowAPIVersionNumber) {
-        return [
-          new core.Violation(
-            new core.FlowAttribute("apiVersion<50", "apiVersion", "<50")
-          )
-        ];
-      }
-
-      // Match something like: >= 58
-      const match = options.expression.match(/^\s*(>=|<=|>|<|===|!==)\s*(\d+)\s*$/);
-      if (!match) {
-        // Invalid expression format
-        return [
-          new core.Violation(
-            new core.FlowAttribute(
-              "Invalid API rule expression",
-              "apiVersion",
-              options.expression
-            )
-          )
-        ];
-      }
-      const [, operator, versionStr] = match;
-      const target = parseFloat(versionStr);
-      let isValid = true;
-      switch (operator) {
-        case ">": isValid = flowAPIVersionNumber > target; break;
-        case "<": isValid = flowAPIVersionNumber < target; break;
-        case ">=": isValid = flowAPIVersionNumber >= target; break;
-        case "<=": isValid = flowAPIVersionNumber <= target; break;
-        case "===": isValid = flowAPIVersionNumber === target; break;
-        case "!==": isValid = flowAPIVersionNumber !== target; break;
-      }
-      if (!isValid) {
-        return [
-          new core.Violation(
-            new core.FlowAttribute(
-              `${flowAPIVersionNumber}`,
-              "apiVersion",
-              options.expression
-            )
-          )
-        ];
-      }
-    } else {
-      // Default: no API version OR version below 50
-      if (!flowAPIVersionNumber || flowAPIVersionNumber < 50) {
-        return [
-          new core.Violation(
-            new core.FlowAttribute(
-              flowAPIVersionNumber ? `${flowAPIVersionNumber}` : "apiVersion<50",
-              "apiVersion",
-              "<50"
-            )
-          )
-        ];
-      }
-    }
-
-    return [];
-  }
-}

package/src/main/rules/ActionCallsInLoop.ts

@@ -1,25 +0,0 @@
-import { FlowType, IRuleDefinition } from "../internals/internals";
-import { LoopRuleCommon } from "../models/LoopRuleCommon";
-export class ActionCallsInLoop extends LoopRuleCommon implements IRuleDefinition {
-  constructor() {
-    super(
-      {
-        ruleId: "action-call-in-loop",
-        category: "suggestion",
-        description: "Repeatedly invoking Apex actions inside a loop can exhaust governor limits and lead to performance issues. Where possible, bulkify your logic by moving the action call outside the loop and passing a collection variable instead.",
-        summary: "Action calls inside loop risk governor limits",
-        docRefs: [
-          {
-            label: "Action Call In A Loop",
-            path: "https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_annotation_InvocableMethod.htm",
-          },
-        ],
-        label: "Action Call In A Loop",
-        name: "ActionCallsInLoop",
-        supportedTypes: FlowType.backEndTypes,
-      }, { severity: "warning" });
-  }
-  protected getStatementTypes(): string[] {
-    return ["actionCalls", "apexPluginCalls"];
-  }
-}

package/src/main/rules/AutoLayout.ts

@@ -1,46 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-export class AutoLayout extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "missing-auto-layout",
-      category: "layout",
-      name: "AutoLayout",
-      label: "Missing Auto Layout",
-      description: "Auto-Layout automatically arranges and aligns Flow elements, keeping the canvas organized and easier to maintain. Enabling it saves time and improves readability.",
-      summary: "Auto-Layout improves canvas organization and readability",
-      supportedTypes: core.FlowType.allTypes(),
-      docRefs: [],
-    }, { severity: "note" });
-  }
-  
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined
-  ): core.Violation[] {
-    if (!flow.processMetadataValues) return [];
-
-    const CanvasMode = flow.xmldata.processMetadataValues.find(
-      (mdv) => mdv.name === "CanvasMode"
-    );
-
-    const autoLayout =
-      CanvasMode?.value &&
-      typeof CanvasMode.value === "object" &&
-      CanvasMode.value.stringValue === "AUTO_LAYOUT_CANVAS";
-
-    if (autoLayout) return [];
-
-    return [
-      new core.Violation(
-        new core.FlowAttribute(
-          CanvasMode?.value?.stringValue ?? "undefined",
-          "CanvasMode",
-          "!== AUTO_LAYOUT_CANVAS"
-        )
-      )
-    ];
-  }
-
-}

package/src/main/rules/CopyAPIName.ts

@@ -1,31 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-export class CopyAPIName extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "unclear-api-naming",
-      category: "layout",
-      name: "CopyAPIName",
-      label: "Unclear API Name",
-      description: "Elements with unclear or duplicated API names, like Copy_X_Of_Element, reduce Flow readability. Make sure to update the API name when copying elements to keep your Flow organized.",
-      summary: "Duplicated API names reduce Flow readability",
-      supportedTypes: core.FlowType.allTypes(),
-      docRefs: [],
-    });
-  }
-  protected check(
-  flow: core.Flow
-): core.Violation[] {
-  const flowElements = flow.elements.filter(
-    (node) => node instanceof core.FlowNode
-  ) as core.FlowNode[];
-
-  const copyOfElements = flowElements.filter(el =>
-    /Copy_[0-9]+_of_[A-Za-z0-9]+/.test(el.name)
-  );
-
-  return copyOfElements.map(el => new core.Violation(el));
-}
-
-}

package/src/main/rules/CyclomaticComplexity.ts

@@ -1,70 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class CyclomaticComplexity extends RuleCommon implements IRuleDefinition {
-  private defaultThreshold: number = 25;
-  private cyclomaticComplexityUnit: number = 0;
-
-  constructor() {
-    super(
-      {
-        ruleId: "excessive-cyclomatic-complexity",
-        category: "suggestion",
-        name: "CyclomaticComplexity",
-        label: "Excessive Cyclomatic Complexity",
-        description: "High numbers of loops and decision elements increase a Flow's cyclomatic complexity. To maintain simplicity and readability, consider using subflows or splitting a Flow into smaller, ordered Flows.",
-        summary: "Too many loops and decisions harm readability",
-        supportedTypes: core.FlowType.backEndTypes,
-        docRefs: [
-          {
-            label: `Cyclomatic complexity is a software metric used to indicate the complexity of a program. It is a quantitative measure of the number of linearly independent paths through a program's source code.`,
-            path: "https://en.wikipedia.org/wiki/Cyclomatic_complexity",
-          },
-        ],
-      },
-      { severity: "note" }
-    );
-  }
-
-  protected check(
-  flow: core.Flow,
-  options: { threshold?: number } | undefined
-): core.Violation[] {
-  const threshold = options?.threshold || this.defaultThreshold;
-  let cyclomaticComplexity = 1;
-
-  const flowDecisions = flow?.elements?.filter(
-    (node) => node.subtype === "decisions"
-  ) as core.FlowElement[];
-
-  const flowLoops = flow?.elements?.filter(
-    (node) => node.subtype === "loops"
-  );
-
-  for (const decision of flowDecisions || []) {
-    const rules = decision.element["rules"];
-    cyclomaticComplexity += Array.isArray(rules)
-      ? rules.length + 1
-      : 1;
-  }
-
-  cyclomaticComplexity += flowLoops?.length ?? 0;
-  this.cyclomaticComplexityUnit = cyclomaticComplexity;
-
-  if (cyclomaticComplexity > threshold) {
-    return [
-      new core.Violation(
-        new core.FlowAttribute(
-          `${cyclomaticComplexity}`,
-          "CyclomaticComplexity",
-          `>${threshold}`
-        )
-      )
-    ];
-  }
-
-  return [];
-}
-
-}

package/src/main/rules/DMLStatementInLoop.ts

@@ -1,26 +0,0 @@
-import { FlowType, IRuleDefinition } from "../internals/internals";
-import { LoopRuleCommon } from "../models/LoopRuleCommon";
-
-export class DMLStatementInLoop extends LoopRuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "dml-in-loop",
-      category: "problem",
-      description: "Executing DML operations (insert, update, delete) inside a loop is a high-risk anti-pattern that frequently causes governor limit exceptions. All database operations should be collected and executed once, outside the loop.",
-      summary: "DML operations inside loop risk governor limits",
-      docRefs: [
-        {
-          label: "Flow Best Practices",
-          path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5",
-        },
-      ],
-      label: "DML Statement In A Loop",
-      name: "DMLStatementInLoop",
-      supportedTypes: FlowType.backEndTypes,
-    }, { severity: "error" });
-  }
-
-  protected getStatementTypes(): string[] {
-    return ["recordDeletes", "recordUpdates", "recordCreates"];
-  }
-}

package/src/main/rules/DuplicateDMLOperation.ts

@@ -1,83 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class DuplicateDMLOperation extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "duplicate-dml",
-      category: "problem",
-      name: "DuplicateDMLOperation",
-      label: "Duplicate DML Operation",
-      description: "When a Flow performs database operations across multiple screens, users navigating backward can cause the same actions to run multiple times. To prevent unintended changes, either restrict backward navigation or redesign the Flow so database operations execute in a single, forward-moving step.",
-      summary: "DML across screens may execute multiple times",
-      supportedTypes: core.FlowType.visualTypes,
-      docRefs: [],
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    suppressions: Set<string>
-  ): core.Violation[] {
-    const graph = flow.graph;
-    const start = flow.startReference;
-
-    if (!start) return [];
-
-    const violations: core.Violation[] = [];
-    const visited = new Set<string>();
-
-    type State = { name: string; seenDML: boolean };
-
-    const stack: State[] = [{ name: start, seenDML: false }];
-
-    while (stack.length > 0) {
-      const { name, seenDML } = stack.pop()!;
-      const stateKey = `${name}:${seenDML}`;
-
-      if (visited.has(stateKey)) continue;
-      visited.add(stateKey);
-
-      const node = graph.getNode(name);
-      if (!node) continue;
-
-      let nextSeenDML = seenDML || this.isDML(node);
-
-      if (
-        nextSeenDML &&
-        node.subtype === "screens" &&
-        node.element["allowBack"] === "true" &&
-        node.element["showFooter"] === "true" &&
-        !suppressions.has(node.name)
-      ) {
-        violations.push(new core.Violation(node));
-        // Note: do NOT return early; multiple violations possible
-      }
-
-      // Reset DML flag after screen with back disabled
-      if (
-        nextSeenDML &&
-        node.subtype === "screens" &&
-        node.element["allowBack"] !== "true"
-      ) {
-        nextSeenDML = false;
-      }
-
-      for (const next of graph.getNextElements(name)) {
-        stack.push({ name: next, seenDML: nextSeenDML });
-      }
-    }
-
-    return violations;
-  }
-
-  private isDML(node: core.FlowNode): boolean {
-    return (
-      node.subtype === "recordCreates" ||
-      node.subtype === "recordUpdates" ||
-      node.subtype === "recordDeletes"
-    );
-  }
-}