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

package/src/main/rules/DuplicateDMLOperation.ts

@@ -1,114 +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({
-      name: "DuplicateDMLOperation",
-      label: "Duplicate DML Operation",
-      description:
-        "When the flow executes database changes or actions between two screens, it's important to prevent users from navigating back between screens. Failure to do so may result in duplicate database operations being performed within the flow.",
-      supportedTypes: core.FlowType.visualTypes,
-      docRefs: [],
-    });
-  }
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    suppressions: Set<string>
-  ): core.Violation[] {
-    const flowElements: core.FlowNode[] = flow.elements.filter(
-      (node) => node instanceof core.FlowNode
-    ) as core.FlowNode[];
-    const processedElementIndexes: number[] = [];
-    const unconnectedElementIndexes: number[] = [];
-    const DuplicateDMLOperations: core.FlowNode[] = [];
-    const startingNode = this.findStart(flow);
-    if (startingNode === -1) {
-      return [];
-    }
-    let dmlFlag = false;
-    let indexesToProcess = [startingNode];
-    do {
-      indexesToProcess = indexesToProcess.filter(
-        (index) => !processedElementIndexes.includes(index)
-      );
-      if (indexesToProcess.length > 0) {
-        for (const [index, element] of flowElements.entries()) {
-          if (indexesToProcess.includes(index)) {
-            const references: string[] = [];
-            if (element.connectors && element.connectors.length > 0) {
-              for (const connector of element.connectors) {
-                if (connector.reference) {
-                  references.push(connector.reference);
-                }
-              }
-            }
-            dmlFlag = this.flagDML(element, dmlFlag);
-            if (references.length > 0) {
-              const elementsByReferences = flowElements.filter((el) =>
-                references.includes(el.name)
-              );
-              for (const nextElement of elementsByReferences) {
-                const nextIndex = flowElements.findIndex(
-                  (el) => nextElement.name === el.name
-                );
-                if (nextElement.subtype === "screens") {
-                  if (
-                    dmlFlag &&
-                    nextElement.element["allowBack"] === "true" &&
-                    nextElement.element["showFooter"] === "true"
-                  ) {
-                    if (!suppressions.has(nextElement.name)) {
-                      DuplicateDMLOperations.push(nextElement);
-                    }
-                  }
-                }
-                if (!processedElementIndexes.includes(nextIndex)) {
-                  indexesToProcess.push(nextIndex);
-                }
-              }
-            }
-            processedElementIndexes.push(index);
-          }
-        }
-      } else {
-        for (const index of flowElements.keys()) {
-          if (!processedElementIndexes.includes(index)) {
-            unconnectedElementIndexes.push(index);
-          }
-        }
-      }
-    } while (
-      processedElementIndexes.length + unconnectedElementIndexes.length <
-      flowElements.length
-    );
-    return DuplicateDMLOperations.map(
-      (det) => new core.Violation(det)
-    );
-  }
-  private findStart(flow: core.Flow): number {
-    const flowElements: core.FlowNode[] = flow.elements.filter(
-      (node) => node instanceof core.FlowNode
-    ) as core.FlowNode[];
-    if (flow.startElementReference) {
-      return flowElements.findIndex((n) => n.name === flow.startElementReference);
-    } else {
-      return flowElements.findIndex((n) => n.subtype === "start");
-    }
-  }
-  private flagDML(element: core.FlowNode, dmlFlag: boolean): boolean {
-    const dmlStatementTypes = ["recordDeletes", "recordUpdates", "recordCreates"];
-    if (dmlStatementTypes.includes(element.subtype)) {
-      return true;
-    } else if (
-      dmlFlag === true &&
-      element.subtype === "screens" &&
-      element.element["allowBack"] === "true"
-    ) {
-      return false;
-    } else {
-      return dmlFlag;
-    }
-  }
-}

package/src/main/rules/FlowDescription.ts

@@ -1,32 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class FlowDescription extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      description:
-        "Descriptions play a vital role in documentation. We highly recommend including details about where they are used and their intended purpose.",
-      docRefs: [],
-      label: "Missing Flow Description",
-      name: "FlowDescription",
-      supportedTypes: [...core.FlowType.backEndTypes, ...core.FlowType.visualTypes],
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    if (flow.xmldata?.description) {
-      return [];
-    }
-
-    return [
-      new core.Violation(
-        new core.FlowAttribute("undefined", "description", "!==null")
-      )
-    ];
-  }
-}

package/src/main/rules/FlowName.ts

@@ -1,40 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class FlowName extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      description:
-        "The readability of a flow is of utmost importance. Establishing a naming convention for the Flow Name significantly enhances findability, searchability, and maintains overall consistency. It is advisable to include at least a domain and a brief description of the actions carried out in the flow, for instance, 'Service_OrderFulfillment'.",
-      docRefs: [
-        {
-          label: "Naming your Flows is more critical than ever. By Stephen Church",
-          path: "https://www.linkedin.com/posts/stephen-n-church_naming-your-flows-this-is-more-critical-activity-7099733198175158274-1sPx",
-        },
-      ],
-      label: "Flow Naming Convention",
-      name: "FlowName",
-      supportedTypes: core.FlowType.allTypes(),
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    options: { expression?: string } | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    const rawRegexp = options?.expression ?? "[A-Za-z0-9]+_[A-Za-z0-9]+";
-    const flowName = flow.name ?? "";
-
-    if (new RegExp(rawRegexp).test(flowName)) {
-      return [];
-    }
-
-    return [
-      new core.Violation(
-        new core.FlowAttribute(flowName, "name", rawRegexp)
-      )
-    ];
-  }
-}

package/src/main/rules/GetRecordAllFields.ts

@@ -1,59 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class GetRecordAllFields extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super(
-      {
-        description:
-          "Following the principle of least privilege (PoLP), avoid using Get Records with 'Automatically store all fields' unless necessary.",
-        docRefs: [
-          {
-            label: "SOQL and SOSL | Best Practices for Deployments with Large Data Volumes",
-            path: "https://developer.salesforce.com/docs/atlas.en-us.salesforce_large_data_volumes_bp.meta/salesforce_large_data_volumes_bp/ldv_deployments_best_practices_soql_and_sosl.htm",
-          },
-          {
-            label: "Indexes | Best Practices",
-            path: "https://developer.salesforce.com/docs/atlas.en-us.salesforce_large_data_volumes_bp.meta/salesforce_large_data_volumes_bp/ldv_deployments_infrastructure_indexes.htm",
-          },
-        ],
-        label: "Get Record All Fields",
-        name: "GetRecordAllFields",
-        supportedTypes: core.FlowType.allTypes(),
-      },
-      { severity: "warning" }
-    );
-  }
-
-  protected check(
-  flow: core.Flow,
-  _options: object | undefined,
-  _suppressions: Set<string>
-): core.Violation[] {
-  const lookupNodes = flow.elements?.filter(
-    (e) => e.subtype === "recordLookups"
-  ) ?? [];
-
-  const violations = lookupNodes
-    .filter((node) => {
-      const el = (node as core.FlowNode).element as core.FlowElement;
-
-      const storeAllFields =
-        typeof el === "object" &&
-        "storeOutputAutomatically" in el &&
-        el.storeOutputAutomatically;
-
-      const hasQueriedFields =
-        typeof el === "object" &&
-        Array.isArray((el as any).queriedFields) &&
-        (el as any).queriedFields.length > 0;
-
-      return storeAllFields && !hasQueriedFields;
-    })
-    .map((node) => new core.Violation(node));
-
-  return violations;
-}
-
-}

package/src/main/rules/HardcodedId.ts

@@ -1,37 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class HardcodedId extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      name: "HardcodedId",
-      label: "Hardcoded Id",
-      description:
-        "Avoid hard-coding IDs as they are org-specific. Instead, pass them into variables at the start of the flow. You can achieve this by utilizing merge fields in URL parameters or employing a Get Records element.",
-      supportedTypes: core.FlowType.allTypes(),
-      docRefs: [
-        {
-          label: "Flow Best Practices",
-          path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5",
-        },
-        {
-          label: "Don't hard code Record Type IDs in Flow. By Stephen Church.",
-          path: "https://www.linkedin.com/feed/update/urn:li:activity:6947530300012826624/",
-        },
-      ],
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    const salesforceIdRegex = /\b[a-zA-Z0-9]{5}0[a-zA-Z0-9]{9}(?:[a-zA-Z0-9]{3})?\b/g;
-
-    return flow.elements
-      .filter((node) => salesforceIdRegex.test(JSON.stringify(node)))
-      .map((node) => new core.Violation(node));
-  }
-}

package/src/main/rules/HardcodedUrl.ts

@@ -1,42 +0,0 @@
-import { Flow, FlowType, Violation } from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class HardcodedUrl extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super(
-      {
-        description:
-          "Avoid hard-coding URLs as they are org-specific. Instead, use a $API formula (preferred) or you can use an environment-specific such as custom labels, custom metadata, or custom settings.",
-        docRefs: [
-          {
-            label: "The Ultimate Guide to Salesforce Flow Best Practices",
-            path: "https://admin.salesforce.com/blog/2021/the-ultimate-guide-to-flow-best-practices-and-standards",
-          },
-          {
-            label: "Why You Should Avoid Hard Coding and Three Alternative Solutions",
-            path: "https://admin.salesforce.com/blog/2021/why-you-should-avoid-hard-coding-and-three-alternative-solutions",
-          },
-        ],
-        label: "Hardcoded Url",
-        name: "HardcodedUrl",
-        supportedTypes: FlowType.allTypes(),
-      },
-      { severity: "warning" }
-    );
-  }
-
-  protected check(
-    flow: Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): Violation[] {
-    if (!flow.elements || flow.elements.length === 0) return [];
-
-    const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}force\.com/g;
-
-    return flow.elements
-      .filter((element) => urlRegex.test(JSON.stringify(element)))
-      .map((element) => new Violation(element));
-  }
-}

package/src/main/rules/InactiveFlow.ts

@@ -1,31 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-
-export class InactiveFlow extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      name: "InactiveFlow",
-      label: "Inactive Flow",
-      description:
-        "Like cleaning out your closet: deleting unused flows is essential. Inactive flows can still cause trouble, like accidentally deleting records during testing, or being activated as subflows within parent flows.",
-      supportedTypes: core.FlowType.allTypes(),
-      docRefs: [],
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    if (flow.status !== "Active") {
-      return [
-        new core.Violation(
-          new core.FlowAttribute(flow.status, "status", "!= Active")
-        ),
-      ];
-    }
-    return [];
-  }
-}

package/src/main/rules/MissingFaultPath.ts

@@ -1,89 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-export class MissingFaultPath extends RuleCommon implements IRuleDefinition {
-  protected applicableElements: string[] = [
-    "recordLookups",
-    "recordDeletes",
-    "recordUpdates",
-    "recordCreates",
-    "waits",
-    "actionCalls",
-  ];
-  constructor() {
-    super({
-      description:
-        "At times, a flow may fail to execute a configured operation as intended. By default, the flow displays an error message to the user and notifies the admin who created the flow via email. However, you can customize this behavior by incorporating a Fault Path.",
-      docRefs: [
-        {
-          label: "Flow Best Practices",
-          path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5",
-        },
-      ],
-      label: "Missing Fault Path",
-      name: "MissingFaultPath",
-      supportedTypes: [...core.FlowType.backEndTypes, ...core.FlowType.visualTypes],
-    });
-  }
-  private isValidSubtype(proxyNode: core.FlowNode): boolean {
-    if (!this.applicableElements.includes(proxyNode.subtype)) {
-      return false;
-    }
-    if (proxyNode.subtype === "waits") {
-      const elementSubtype: string = (proxyNode.element as Record<string, unknown>)?.["elementSubtype"] as string;
-      const excludedSubtypes: string[] = ["WaitDuration", "WaitDate"];
-      return !excludedSubtypes.includes(elementSubtype);
-    }
-    return true;
-  }
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    suppressions: Set<string>
-  ): core.Violation[] {
-    const compiler = new core.Compiler();
-    const results: core.Violation[] = [];
-    const elementsWhereFaultPathIsApplicable = (
-      flow.elements?.filter((node) => {
-        const proxyNode = node as unknown as core.FlowNode;
-        return this.isValidSubtype(proxyNode);
-      }) as core.FlowNode[]
-    ).map((e) => e.name);
-    const isRecordBeforeSave = flow.start.triggerType === "RecordBeforeSave";
-    const visitCallback = (element: core.FlowNode) => {
-      if (
-        !element?.connectors?.find((connector) => connector.type === "faultConnector") &&
-        elementsWhereFaultPathIsApplicable.includes(element.name)
-      ) {
-        if (isRecordBeforeSave && element.subtype === "recordUpdates") {
-          return;
-        }
-        if (!this.isPartOfFaultHandlingFlow(element, flow)) {
-          if (!suppressions.has(element.name)) {
-            results.push(new core.Violation(element));
-          }
-        }
-      }
-    };
-    compiler.traverseFlow(flow, flow.startReference, visitCallback);
-    return results;
-  }
-  private isPartOfFaultHandlingFlow(element: core.FlowNode, flow: core.Flow): boolean {
-    const flowelements = flow.elements?.filter(
-      (el) => el instanceof core.FlowNode
-    ) as core.FlowNode[];
-    for (const otherElement of flowelements) {
-      if (otherElement !== element) {
-        if (
-          otherElement.connectors?.find(
-            (connector) =>
-              connector.type === "faultConnector" && connector.reference === element.name
-          )
-        ) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-}

package/src/main/rules/MissingMetadataDescription.ts

@@ -1,39 +0,0 @@
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-
-export class MissingMetadataDescription extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      description: "Every element must have a meaningful description",
-      docRefs: [],
-      label: "Missing Metadata Description",
-      name: "MissingMetadataDescription",
-      supportedTypes: core.FlowType.allTypes(),
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppression: Set<string>
-  ): core.Violation[] {
-    const violations: core.Violation[] = [];
-
-    flow.elements
-      .filter((elem) => {
-        if (
-          elem.metaType !== "metadata" &&
-          !elem.element["description"] &&
-          elem.subtype !== "start"
-        ) {
-          return elem;
-        }
-      })
-      .forEach((elem) => {
-        return violations.push(new core.Violation(elem));
-      });
-
-    return violations;
-  }
-}

package/src/main/rules/MissingNullHandler.ts

@@ -1,95 +0,0 @@
-import * as core from "../internals/internals";
-import { RuleCommon } from "../models/RuleCommon";
-import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-export class MissingNullHandler extends RuleCommon implements IRuleDefinition {
-  constructor() {
-    super({
-      description:
-        "When a Get Records operation doesn't find any data, it returns null. To ensure data validation, utilize a decision element on the operation result variable to check for a non-null result.",
-      docRefs: [],
-      label: "Missing Null Handler",
-      name: "MissingNullHandler",
-      supportedTypes: [...core.FlowType.backEndTypes, ...core.FlowType.visualTypes],
-    });
-  }
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    suppressions: Set<string>
-  ): core.Violation[] {
-    const getOperations = ["recordLookups"];
-    const getOperationElements: core.FlowNode[] = flow.elements.filter(
-      (node) => node.metaType === "node" && getOperations.includes(node.subtype)
-    ) as core.FlowNode[];
-    const decisionElements: core.FlowNode[] = flow.elements.filter(
-      (node) => node.metaType === "node" && node.subtype === "decisions"
-    ) as core.FlowNode[];
-    const violations: core.FlowNode[] = [];
-    for (const getElement of getOperationElements) {
-      if (suppressions.has(getElement.name)) continue;
-      const elementName = getElement.name;
-      const assignNulls = String(getElement.element["assignNullValuesIfNoRecordsFound"]).toLowerCase() === "true";
-      if (!assignNulls) continue;
-      const hasFaultConnector =
-        !!getElement.element["faultConnector"] ||
-        getElement.connectors?.some((c) => c.type === "faultConnector");
-      if (hasFaultConnector) continue;
-      const resultReferences: string[] = [];
-      if (getElement.element["storeOutputAutomatically"]) {
-        resultReferences.push(elementName);
-      } else if (getElement.element["outputReference"]) {
-        resultReferences.push(getElement.element["outputReference"] as string);
-      } else if (getElement.element["outputAssignments"]) {
-        const assignments = getElement.element["outputAssignments"] as any[];
-        for (const a of assignments) {
-          resultReferences.push(a.assignToReference);
-        }
-      }
-      const resultIsUsed = flow.elements.some((el) => {
-        if (el.name === getElement.name) return false;
-        const json = JSON.stringify(el.element);
-        return resultReferences.some(
-          (ref) => json.includes(`"${ref}"`) || json.includes(`"${ref}.`)
-        );
-      });
-      if (!resultIsUsed) continue;
-      let nullCheckFound = false;
-      for (const decision of decisionElements) {
-        let rules = decision.element["rules"];
-        if (!Array.isArray(rules)) rules = [rules];
-        for (const rule of rules) {
-          let conditions = rule.conditions;
-          if (!Array.isArray(conditions)) conditions = [conditions];
-          for (const condition of conditions) {
-            let referenceFound = false;
-            let isNullOperator = false;
-            let checksFalse = false;
-            if (condition.leftValueReference) {
-              const ref = condition.leftValueReference as string;
-              if (resultReferences.some((r) => ref.startsWith(r))) {
-                referenceFound = true;
-              }
-            }
-            if (condition.operator === "IsNull") {
-              isNullOperator = true;
-            }
-            const rightBool = condition.rightValue?.booleanValue;
-            if (rightBool != null && String(rightBool).toLowerCase() === "false") {
-              checksFalse = true;
-            }
-            if (referenceFound && isNullOperator && checksFalse) {
-              nullCheckFound = true;
-              break;
-            }
-          }
-          if (nullCheckFound) break;
-        }
-        if (nullCheckFound) break;
-      }
-      if (!nullCheckFound) {
-        violations.push(getElement);
-      }
-    }
-    return violations.map((det) => new core.Violation(det));
-  }
-}

package/src/main/rules/ProcessBuilder.ts

@@ -1,33 +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({
-      name: "ProcessBuilder",
-      label: "No Process Builder",
-      description:
-        "Salesforce is transitioning away from Workflow Rules and Process Builder in favor of Flow. Ensure you're prepared for this transition by migrating your organization's automation to Flow. Refer to official documentation for more information on the transition process and tools available.",
-      supportedTypes: core.FlowType.processBuilder,
-      docRefs: [
-        {
-          label: "Process Builder Retirement",
-          path: "https://help.salesforce.com/s/articleView?id=000389396&type=1",
-        },
-      ],
-    });
-  }
-
-  protected check(
-    flow: core.Flow,
-    _options: object | undefined,
-    _suppressions: Set<string>
-  ): core.Violation[] {
-    return [
-      new core.Violation(
-        new core.FlowAttribute("Workflow", "processType", "== Workflow")
-      ),
-    ];
-  }
-}