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

package/src/main/rules/RecursiveAfterUpdate.ts

@@ -1,88 +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(
-      {
-        description:
-          "After updates are meant to be used for record modifications that are not the same record that triggered the flow. Using after updates on the same record can lead to recursion and unexpected behavior. Consider using before save flows for same record updates.",
-        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 isAfterSave = flow.start?.triggerType === "RecordAfterSave";
-    const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(
-      flow.start?.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 lookupElementsWithTheSameObjectType = flow.elements
-      ?.filter(
-        (node) =>
-          node.subtype === "recordLookups" &&
-          typeof node.element === "object" &&
-          "object" in node.element &&
-          flow.start.object === 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,24 +0,0 @@
-import { FlowType, IRuleDefinition } from "../internals/internals";
-import { LoopRuleCommon } from "../models/LoopRuleCommon";
-
-export class SOQLQueryInLoop extends LoopRuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      description:
-        "To prevent exceeding Apex governor limits, it is advisable to consolidate all your SOQL queries at the conclusion of the flow.",
-      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,
-    });
-  }
-
-  protected getStatementTypes(): string[] {
-    return ["recordLookups"];
-  }
-}

package/src/main/rules/SameRecordFieldUpdates.ts

@@ -1,64 +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(
-      {
-        name: "SameRecordFieldUpdates",
-        label: "Same Record Field Updates",
-        description:
-          "Before-save same-record field updates allows you to update the record using variable assignments to `$Record`. This is significantly faster than doing another DML on the same-record that triggered the flow",
-        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 isBeforeSaveType = flow.start?.triggerType === "RecordBeforeSave";
-    const isQualifiedTriggerTypes = this.qualifiedRecordTriggerTypes.has(
-      flow.start?.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/TriggerOrder.ts

@@ -1,44 +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 {
-  protected qualifiedRecordTriggerTypes: Set<string> = new Set<string>(["Create", "Update"]);
-
-  constructor() {
-    super(
-      {
-        name: "TriggerOrder",
-        label: "Trigger Order",
-        description:
-          "With flow trigger ordering, introduced in Spring '22, admins can now assign a priority value to their flows and guarantee their execution order. This priority value is not an absolute value, so the values need not be sequentially numbered as 1, 2, 3, and so on.",
-        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[] {
-    if (!("object" in flow.start)) return [];
-
-    if (!flow.triggerOrder) {
-      return [
-        new core.Violation(
-          new core.FlowAttribute("TriggerOrder", "TriggerOrder", "10, 20, 30 ...")
-        ),
-      ];
-    }
-
-    return [];
-  }
-}

package/src/main/rules/UnconnectedElement.ts

@@ -1,48 +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({
-      description:
-        "To maintain the efficiency and manageability of your Flow, it's best to avoid including unconnected elements that are not in use.",
-      docRefs: [],
-      label: "Unconnected 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> = new Set<string>();
-    const logConnected = (element: core.FlowNode) => {
-      connectedElements.add(element.name);
-    };
-
-    const flowElements: core.FlowNode[] = flow.elements!.filter(
-      (node) => node instanceof core.FlowNode
-    ) as core.FlowNode[];
-
-    const startIndex = this.findStart(flowElements);
-    if (startIndex !== -1) {
-      new core.Compiler().traverseFlow(flow, flowElements[startIndex].name, logConnected);
-    }
-
-    const unconnectedElements: core.FlowNode[] = flowElements.filter(
-      (element) => !connectedElements.has(element.name) && !suppressions.has(element.name)
-    );
-
-    return unconnectedElements.map((det) => new core.Violation(det));
-  }
-
-  private findStart(nodes: core.FlowNode[]) {
-    return nodes.findIndex((n) => {
-      return n.subtype === "start";
-    });
-  }
-}

package/src/main/rules/UnsafeRunningContext.ts

@@ -1,44 +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({
-      name: "UnsafeRunningContext",
-      label: "Unsafe Running Context",
-      description: `This flow is configured to run in System Mode without Sharing. This system context grants all running users the permission to view and edit all data in your org. Running a flow in System Mode without Sharing can lead to unsafe data access.`,
-      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: "warning" });
-  }
-
-  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,64 +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({
-      name: "UnusedVariable",
-      label: "Unused Variable",
-      description:
-        "To maintain the efficiency and manageability of your Flow, it's advisable to avoid including unconnected variables that are not in use.",
-      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/src/main/store/DefaultRuleStore.ts

@@ -1,54 +0,0 @@
-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 { 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";
-
-export const DefaultRuleStore: object = {
-  ActionCallsInLoop,
-  APIVersion,
-  AutoLayout,
-  CopyAPIName,
-  CyclomaticComplexity,
-  DMLStatementInLoop,
-  DuplicateDMLOperation,
-  FlowDescription,
-  FlowName,
-  GetRecordAllFields,
-  HardcodedId,
-  HardcodedUrl,
-  InactiveFlow,
-  MissingFaultPath,
-  MissingNullHandler,
-  ProcessBuilder,
-  RecursiveAfterUpdate,
-  SameRecordFieldUpdates,
-  SOQLQueryInLoop,
-  TriggerOrder,
-  UnconnectedElement,
-  UnsafeRunningContext,
-  UnusedVariable,
-};
-
-export const BetaRuleStore: object = {
-  MissingMetadataDescription,
-};

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,83 +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, "../../../assets/example-flows/force-app/main/default/flows/demo/Outdated_API_Version.flow-meta.xml");
-  const fixed_uri = path.join(__dirname, "../../../assets/example-flows/force-app/main/default/flows/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 = {
-      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 = {
-      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 = {
-      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 = {
-      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);
-    }
-  });
-});

package/tests/AutoLayout.test.ts

@@ -1,39 +0,0 @@
-import * as core from "../src";
-import * as path from "path";
-
-import { describe, it, expect } from "@jest/globals";
-
-describe("Autolayout", () => {
-  const example_uri = path.join(__dirname, "../../../assets/example-flows/force-app/main/default/flows/demo/Unconnected_Element.flow-meta.xml");
-  const fixed_uri = path.join(__dirname, "../../../assets/example-flows/force-app/main/default/flows/testing/Outdated_API_Version_Fixed.flow-meta.xml");
-
-  it("should have a result when CanvasMode is set to FREE_FORM_CANVAS", async () => {
-    const flows = await core.parse([example_uri]);
-    const ruleConfig = {
-      rules: {
-        AutoLayout: {
-          severity: "error",
-        },
-      },
-    };
-
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
-    expect(occurringResults).toHaveLength(1);
-    expect(occurringResults.find((res) => res.ruleName === "AutoLayout")).toBeTruthy();
-  });
-
-  it("should not have result when autolayout is configured", async () => {
-    const flows = await core.parse([fixed_uri]);
-    const ruleConfig = {
-      rules: {
-        AutoLayout: {
-          severity: "error",
-        },
-      },
-    };
-    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
-    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
-    expect(occurringResults).toHaveLength(0);
-  });
-});