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

package/src/main/rules/ProcessBuilder.ts

@@ -1,35 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class ProcessBuilder extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "process-builder-usage",
-      category: "problem",
-      name: "ProcessBuilder",
-      label: "Process Builder",
-      description: "Process Builder is retired. Continuing to use it increases maintenance overhead and risks future compatibility issues. Migrating automation to Flow reduces risk and improves maintainability.",
-      summary: "Process Builder is retired, migrate to Flow",
-      supportedTypes: core.FlowType.processBuilder,
-      docRefs: [
-        {
-          label: "Process Builder Retirement",
-          path: "https://help.salesforce.com/s/articleView?id=000389396&type=1",
-        },
-      ],
-    }, { severity: "error" });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    return [
-      new core.Violation(
-        new core.FlowAttribute("Workflow", "processType", "== Workflow")
-      ),
-    ];
-  }
-}

package/src/main/rules/RecordIdAsString.ts

@@ -1,64 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class RecordIdAsString extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "record-id-as-string",
-      category: "suggestion",
-      name: "RecordIdAsString",
-      label: "Record ID as String",
-      description: "Flows that use a String variable for a record ID instead of receiving the full record introduce unnecessary complexity and additional Get Records queries. Using the complete record simplifies the Flow and improves performance.",
-      summary: "String record IDs add complexity and queries",
-      supportedTypes: [
-        ...core.FlowType.visualTypes,
-        core.FlowType.autolaunchedType,
-      ],
-      docRefs: [
-        {
-          label: "Screen Flow Distribution",
-          path: "https://help.salesforce.com/s/articleView?id=sf.flow_distribute_screen.htm",
-        },
-      ],
-    }, { severity: "note" });
-  }
-
-  protected check(
-  flow: core.Flow,
-  _options: object | undefined,
-  _suppressions: Set<string>
-): core.Violation[] {
-  const violations: core.Violation[] = [];
-
-  // Skip record-triggered flows - they don't support this pattern
-  const triggerType = this.getStartProperty(flow, 'triggerType');
-  const isRecordTriggered = 
-    triggerType === "RecordAfterSave" || 
-    triggerType === "RecordBeforeDelete" || 
-    triggerType === "RecordBeforeSave";
-
-  if (isRecordTriggered) {
-    return violations;
-  }
-
-  // Find input variables named "recordId" (case-insensitive)
-  const variables = flow.elements?.filter(
-    (e) => e.subtype === "variables"
-  ) as core.FlowVariable[];
-
-  for (const variable of variables) {
-    const varElement = variable.element as any;
-    
-    if (
-      (varElement.isInput === true || varElement.isInput === "true") &&
-      variable.name.toLowerCase() === "recordid" &&
-      varElement.dataType === "String"
-    ) {
-      violations.push(new core.Violation(variable));
-    }
-  }
-
-  return violations;
-}
-}

package/src/main/rules/RecursiveAfterUpdate.ts

@@ -1,94 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-export class RecursiveAfterUpdate extends RuleCommon implements IRuleDefinition {
-  protected qualifiedRecordTriggerTypes: Set<string> = new Set<string>([
-    "Create",
-    "CreateAndUpdate",
-    "Update",
-  ]);
-  constructor() {
-    super(
-      {
-        ruleId: "recursive-record-update",
-        category: "problem",
-        description: "After-save Flows that update the same record can trigger recursion, causing unintended behavior or performance issues. Avoid updating the triggering record in after-save Flows; use before-save Flows instead to prevent recursion.",
-        summary: "After-save updates to same record trigger recursion",
-        docRefs: [
-          {
-            label: "Learn about same record field updates",
-            path: "https://architect.salesforce.com/decision-guides/trigger-automation#Same_Record_Field_Updates",
-          },
-        ],
-        label: "Recursive After Update",
-        name: "RecursiveAfterUpdate",
-        supportedTypes: [...core.FlowType.backEndTypes],
-      },
-      { severity: "warning" }
-    );
-  }
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    suppressions: Set<string>
-  ): core.Violation[] {
-    const results: core.Violation[] = [];
-
-    const triggerType = this.getStartProperty(flow, 'triggerType');
-    const recordTriggerType = this.getStartProperty(flow, 'recordTriggerType');
-
-    const isAfterSave = triggerType === "RecordAfterSave";
-    const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(recordTriggerType);
-
-    if (!isAfterSave || !isQualifiedTriggerTypes) {
-      return results;
-    }
-    const potentialElements = flow.elements?.filter(
-      (node) => node.subtype === "recordUpdates"
-    ) as core.FlowNode[];
-    if (potentialElements == null || typeof potentialElements[Symbol.iterator] !== "function") {
-      return results;
-    }
-    // === $Record updates ===
-    for (const node of potentialElements) {
-      if (
-        typeof node.element === "object" &&
-        "inputReference" in node.element &&
-        node.element.inputReference === "$Record"
-      ) {
-        if (!suppressions.has(node.name)) {
-          results.push(new core.Violation(node));
-        }
-      }
-    }
-    // === Lookup → same object type updates ===
-    const flowObject = this.getStartProperty(flow, 'object');
-    const lookupElementsWithTheSameObjectType = flow.elements
-      ?.filter(
-        (node) =>
-          node.subtype === "recordLookups" &&
-          typeof node.element === "object" &&
-          "object" in node.element &&
-          flowObject  === node.element["object"]
-      )
-      ?.map((node) => node.name);
-    if (
-      lookupElementsWithTheSameObjectType == null ||
-      typeof lookupElementsWithTheSameObjectType[Symbol.iterator] !== "function"
-    ) {
-      return results;
-    }
-    for (const node of potentialElements) {
-      if (
-        typeof node.element === "object" &&
-        "inputReference" in node.element &&
-        lookupElementsWithTheSameObjectType.includes(node.element.inputReference as string)
-      ) {
-        if (!suppressions.has(node.name)) {
-          results.push(new core.Violation(node));
-        }
-      }
-    }
-    return results;
-  }
-}

package/src/main/rules/SOQLQueryInLoop.ts

@@ -1,26 +0,0 @@
-import { FlowType, IRuleDefinition } from "../internals/internals";
-import { LoopRuleCommon } from "../models/LoopRuleCommon";
-
-export class SOQLQueryInLoop extends LoopRuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "soql-in-loop",
-      category: "problem",
-      description: "Running SOQL queries inside a loop can rapidly exceed query limits and severely degrade performance. Queries should be executed once, with results reused throughout the loop.",
-      summary: "SOQL queries 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: "SOQL Query In A Loop",
-      name: "SOQLQueryInLoop",
-      supportedTypes: FlowType.backEndTypes,
-    }, { severity: "error" });
-  }
-
-  protected getStatementTypes(): string[] {
-    return ["recordLookups"];
-  }
-}

package/src/main/rules/SameRecordFieldUpdates.ts

@@ -1,66 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class SameRecordFieldUpdates extends RuleCommon implements IRuleDefinition {
-  protected qualifiedRecordTriggerTypes: Set<string> = new Set<string>([
-    "Create",
-    "Update",
-    "CreateAndUpdate",
-  ]);
-
-  constructor() {
-    super(
-      {
-        ruleId: "same-record-field-updates",
-        category: "suggestion",
-        name: "SameRecordFieldUpdates",
-        label: "Same Record Field Updates",
-        description: "Before-save Flows can safely update the triggering record directly via $Record, applying changes efficiently without extra DML operations. Using before-save updates improves performance",
-        summary: "Before-save Flows can update $Record directly",
-        supportedTypes: [...core.FlowType.backEndTypes],
-        docRefs: [
-          {
-            label: "Learn about same record field updates",
-            path: "https://architect.salesforce.com/decision-guides/trigger-automation#Same_Record_Field_Updates",
-          },
-        ],
-      },
-      { severity: "warning" }
-    );
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    const results: core.Violation[] = [];
-    const triggerType = this.getStartProperty(flow, 'triggerType');
-    const recordTriggerType = this.getStartProperty(flow, 'recordTriggerType');
-
-    const isBeforeSaveType = triggerType === "RecordBeforeSave";
-    const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(recordTriggerType);
-    if (!isBeforeSaveType || !isQualifiedTriggerTypes) {
-      return results;
-    }
-
-    const potentialElements = flow.elements?.filter(
-      (node) => node.subtype === "recordUpdates"
-    ) as core.FlowNode[];
-
-    if (!potentialElements) return results;
-
-    for (const node of potentialElements) {
-      if (
-        typeof node.element === "object" &&
-        "inputReference" in node.element &&
-        node.element.inputReference === "$Record"
-      ) {
-        results.push(new core.Violation(node));
-      }
-    }
-
-    return results;
-  }
-}

package/src/main/rules/TransformInsteadOfLoop.ts

@@ -1,56 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class TransformInsteadOfLoop extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "transform-instead-of-loop",
-      category: "suggestion",
-      name: "TransformInsteadOfLoop",
-      label: "Transform Instead of Loop",
-      description: "Loop elements that perform direct Assignments on each item can slow down Flows. Using Transform elements allows bulk operations on collections, improving performance and reducing complexity.",
-      summary: "Transform elements enable faster bulk operations",
-      supportedTypes: core.FlowType.allTypes(),
-      docRefs: [
-        {
-          label: "Transform Multiple Records - Trailhead",
-          path: "https://trailhead.salesforce.com/content/learn/modules/multirecord-elements-and-transforms-in-flows/transform-multiple-records",
-        },
-      ],
-    }, { severity: "note" });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    const violations: core.Violation[] = [];
-
-    const triggerType = this.getStartProperty(flow, 'triggerType');
-    const isRecordBeforeSave = triggerType === "RecordBeforeSave";
-    if (isRecordBeforeSave) {
-      return violations;
-    }
-
-    const loops = flow.graph.getLoopNodes();
-
-    for (const loopNode of loops) {
-      // Get elements that the loop connects to (includes nextValueConnector)
-      const nextElements = flow.graph.getNextElements(loopNode.name);
-
-      // Check if any directly connected element is an assignment
-      for (const nextElementName of nextElements) {
-        const nextElement = flow.graph.getNode(nextElementName);
-
-        if (nextElement?.subtype === "assignments") {
-          violations.push(new core.Violation(loopNode));
-          break; // Only report once per loop
-        }
-      }
-    }
-
-    return violations;
-  }
-}

package/src/main/rules/TriggerOrder.ts

@@ -1,51 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class TriggerOrder extends RuleCommon implements IRuleDefinition {
-
-  constructor() {
-    super(
-      {
-        ruleId: "unspecified-trigger-order",
-        category: "suggestion",
-        name: "TriggerOrder",
-        label: "Missing Trigger Order",
-        description: "Record-triggered Flows without a specified Trigger Order may execute in an unpredictable sequence. Setting a Trigger Order ensures your Flows run in the intended order.",
-        summary: "Trigger Order ensures predictable execution sequence",
-        supportedTypes: [core.FlowType.autolaunchedType],
-        docRefs: [
-          {
-            label: "Learn more about flow ordering orchestration",
-            path: "https://architect.salesforce.com/decision-guides/trigger-automation#Ordering___Orchestration",
-          },
-        ],
-      },
-      { severity: "note" }
-    );
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-
-    const startObject = this.getStartProperty(flow, "object");
-    // If there's no `object` on the start node, this is NOT a record-triggered flow
-    if (!startObject) {
-      return [];
-    }
-
-    // This *is* a record-triggered flow → should have triggerOrder
-    if (!flow.triggerOrder) {
-      return [
-        new core.Violation(
-          new core.FlowAttribute("TriggerOrder", "TriggerOrder", "10, 20, 30 ...")
-        ),
-      ];
-    }
-
-    return [];
-  }
-}

package/src/main/rules/UnconnectedElement.ts

@@ -1,32 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-export class UnconnectedElement extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "unreachable-element",
-      category: "layout",
-      description: "Unconnected elements never execute and add unnecessary clutter. Remove or connect unused Flow elements to keep Flows clean and efficient.",
-      summary: "Unconnected elements add clutter without executing",
-      docRefs: [],
-      label: "Unreachable Element",
-      name: "UnconnectedElement",
-      supportedTypes: [...core.FlowType.backEndTypes, ...core.FlowType.visualTypes],
-    });
-  }
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    suppressions: Set<string>
-  ): core.Violation[] {
-    const connectedElements: Set<string> = flow.graph?.getReachableElements() || new Set<string>();
-
-    const flowElements: core.FlowNode[] = flow.elements.filter(
-      (node): node is core.FlowNode => node instanceof core.FlowNode
-    );
-    const unconnectedElements: core.FlowNode[] = flowElements.filter(
-      (element) => !connectedElements.has(element.name) && !suppressions.has(element.name)
-    );
-    return unconnectedElements.map((det) => new core.Violation(det));
-  }
-}

package/src/main/rules/UnsafeRunningContext.ts

@@ -1,47 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class UnsafeRunningContext extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "unsafe-running-context",
-      category: "problem",
-      name: "UnsafeRunningContext",
-      label: "Unsafe Running Context",
-      description: "Flows configured to run in System Mode without Sharing grant access to all data, bypassing user permissions. Avoid this setting to prevent security risks and protect sensitive data.",
-      summary: "System mode without sharing creates security risks",
-      supportedTypes: [...core.FlowType.backEndTypes, ...core.FlowType.visualTypes],
-      docRefs: [
-        {
-          label:
-            "Learn about data safety when running flows in system context in Salesforce Help",
-          path: "https://help.salesforce.com/s/articleView?id=sf.flow_distribute_context_data_safety_system_context.htm&type=5",
-        },
-      ],
-    }, { severity: "error" });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    if (!("runInMode" in flow.xmldata)) {
-      return [];
-    }
-
-    const runInMode: string = flow.xmldata.runInMode;
-    const riskyMode: string = "SystemModeWithoutSharing";
-
-    if (runInMode === riskyMode) {
-      return [
-        new core.Violation(
-          new core.FlowAttribute(runInMode, "runInMode", `== ${riskyMode}`)
-        )
-      ];
-    }
-
-    return [];
-  }
-}

package/src/main/rules/UnusedVariable.ts

@@ -1,66 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class UnusedVariable extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      ruleId: "unused-variable",
-      category: "layout",
-      name: "UnusedVariable",
-      label: "Unused Variable",
-      description: "Unused variables are never referenced and add unnecessary clutter. Remove them to keep Flows efficient and easy to maintain.",
-      summary: "Unused variables add clutter and hurt maintainability",
-      supportedTypes: [...core.FlowType.backEndTypes, ...core.FlowType.visualTypes],
-      docRefs: [],
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    const variables = flow.elements.filter(
-      (node) => node instanceof core.FlowVariable
-    ) as core.FlowVariable[];
-
-    const unusedVariables: core.FlowVariable[] = [];
-
-    for (const variable of variables) {
-      const variableName = variable.name;
-
-      const nodeMatches = [
-        ...JSON.stringify(flow.elements.filter((node) => node instanceof core.FlowNode)).matchAll(
-          new RegExp(variableName, "gi")
-        ),
-      ].map((a) => a.index);
-
-      if (nodeMatches.length > 0) continue;
-
-      const resourceMatches = [
-        ...JSON.stringify(flow.elements.filter((node) => node instanceof core.FlowResource)).matchAll(
-          new RegExp(variableName, "gi")
-        ),
-      ].map((a) => a.index);
-
-      if (resourceMatches.length > 0) continue;
-
-      const insideCounter = [
-        ...JSON.stringify(variable).matchAll(new RegExp(variable.name, "gi")),
-      ].map((a) => a.index);
-
-      const variableUsage = [
-        ...JSON.stringify(flow.elements.filter((node) => node instanceof core.FlowVariable)).matchAll(
-          new RegExp(variableName, "gi")
-        ),
-      ].map((a) => a.index);
-
-      if (variableUsage.length === insideCounter.length) {
-        unusedVariables.push(variable);
-      }
-    }
-
-    return unusedVariables.map((variable) => new core.Violation(variable));
-  }
-}

package/stryker.config.mjs

@@ -1,23 +0,0 @@
-// @ts-check
-/** @type {import('@stryker-mutator/api/core').PartialStrykerOptions} */
-const config = {
-  _comment:
-    "This config was generated using 'stryker init'. Please take a look at: https://stryker-mutator.io/docs/stryker-js/configuration/ for more information.",
-  packageManager: "npm",
-  reporters: ["html", "clear-text", "progress", "dashboard"],
-  commandRunner: { command: "npm test" },
-  testRunner: "jest",
-  jest: {
-    config: {
-      testEnvironment: "node",
-    },
-    enableFindRelatedTests: true,
-  },
-  testRunnerNodeArgs: ["--experimental-vm-modules"],
-  testRunner_comment:
-    "Take a look at https://stryker-mutator.io/docs/stryker-js/jest-runner for information about the jest plugin.",
-  coverageAnalysis: "perTest",
-  mutate: ["src/**/*.ts", "!tests/**/*.test.ts"],
-  ignoreStatic: true,
-};
-export default config;

package/tests/APIVersion.test.ts

@@ -1,87 +0,0 @@
-import * as core from "../src";
-import * as path from "path";
-
-import { describe, it, expect } from "@jest/globals";
-
-describe("APIVersion", () => {
-  const example_uri = path.join(__dirname, "../../../example-flows/force-app/demo/Invalid_API_Version.flow-meta.xml");
-  const fixed_uri = path.join(__dirname, "../../../example-flows/force-app/testing/Outdated_API_Version_Fixed.flow-meta.xml");
-
-  it("should have a result when attribute is missing", async () => {
-    const flows = await core.parse([example_uri]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        APIVersion: {
-          severity: "error",
-        },
-      },
-    };
-
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results[0].ruleResults).toHaveLength(1);
-    expect(results[0].ruleResults[0].ruleName).toBe("APIVersion");
-    expect(results[0].ruleResults[0].occurs).toBe(true);
-  });
-
-  it("should have a result when below configured threshold", async () => {
-    const flows = await core.parse([example_uri]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        APIVersion: {
-          severity: "error",
-          expression: ">55",
-        },
-      },
-    };
-
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results[0].ruleResults).toHaveLength(1);
-    expect(results[0].ruleResults[0].ruleName).toBe("APIVersion");
-    expect(results[0].ruleResults[0].occurs).toBe(true);
-  });
-
-  it("should have no result when version is meeting threshold", async () => {
-    const flows = await core.parse([fixed_uri]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        APIVersion: {
-          severity: "error",
-          expression: ">55",
-        },
-      },
-    };
-
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results[0].ruleResults).toHaveLength(1);
-    expect(results[0].ruleResults[0].ruleName).toBe("APIVersion");
-    expect(results[0].ruleResults[0].occurs).toBe(false);
-  });
-
-  it("should have a result when configured is more than what the file has", async () => {
-    const flows = await core.parse([fixed_uri]);
-    const ruleConfig = {
-      ruleMode: "isolated",
-      rules: {
-        APIVersion: {
-          severity: "error",
-          expression: ">=60",
-        },
-      },
-    };
-
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    expect(results[0].ruleResults).toHaveLength(1);
-    expect(results[0].ruleResults[0].ruleName).toBe("APIVersion");
-    expect(results[0].ruleResults[0].occurs).toBe(true);
-
-    const violations = results[0].ruleResults[0].details;
-    if (violations.length > 0) {
-      // ensure tag level line numbers are correct
-      expect(violations[0].lineNumber).toBeDefined();
-      expect(violations[0].lineNumber).toBeGreaterThan(1);
-    }
-  });
-});