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

package/tests/RecursiveAfterUpdate.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from "@jest/globals";
+import { Flow, RuleResult, scan } from "../src";
+import { ParsedFlow } from "../src/main/models/ParsedFlow";
+import { RecursiveAfterUpdate } from "../src/main/rules/RecursiveAfterUpdate";
+
+describe("RecursiveAfterUpdate", () => {
+  const rule = new RecursiveAfterUpdate();
+
+  describe("e2e", () => {
+    it("should trigger from when opt-in", () => {
+      const testData: ParsedFlow = {
+        flow: {
+          elements: [
+            {
+              element: {
+                inputReference: "$Record",
+              },
+              metaType: "node",
+              subtype: "recordUpdates",
+            },
+          ],
+          startNode: {
+            element: {
+              recordTriggerType: "Create",
+              triggerType: "RecordAfterSave",
+              object: "Account"
+            }
+          },
+          type: "AutoLaunchedFlow",
+        },
+      } as Partial<ParsedFlow> as ParsedFlow;
+
+      const ruleConfig = {
+        ruleMode: "isolated",
+        exceptions: {},
+        rules: {
+          RecursiveAfterUpdate: {
+            severity: "error",
+          },
+        },
+      };
+      const results = scan([testData], ruleConfig);
+      const scanResults = results.pop();
+
+      expect(
+        scanResults?.ruleResults.some(
+          (ruleResult) => ruleResult.ruleName === "RecursiveAfterUpdate"
+        )
+      ).toBeTruthy();
+      expect(
+        scanResults?.ruleResults?.find(
+          (ruleResult) => ruleResult.ruleName === "RecursiveAfterUpdate"
+        )?.occurs
+      ).toBeTruthy();
+    });
+  });
+
+  describe("units", () => {
+    describe("when using inputReference as $Record", () => {
+      it("should trigger when matching record input reference", () => {
+        const testData: ParsedFlow = {
+          flow: {
+            elements: [
+              {
+                element: {
+                  inputReference: "$Record",
+                },
+                metaType: "node",
+                subtype: "recordUpdates",
+              },
+            ],
+            startNode: {
+              element: {
+                recordTriggerType: "CreateAndUpdate",
+                triggerType: "RecordAfterSave",
+                object: "Account"
+              }
+            },
+          },
+        } as Partial<ParsedFlow> as ParsedFlow;
+
+        const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
+        expect(ruleResult.occurs).toBe(true);
+      });
+
+      it("should not trigger when not matching record input reference", () => {
+        const testData: ParsedFlow = {
+          flow: {
+            elements: [
+              {
+                element: {
+                  inputReference: "SomethingElse",
+                },
+                metaType: "node",
+                subtype: "recordUpdates",
+              },
+            ],
+            startNode: {
+              element: {
+                recordTriggerType: "CreateAndUpdate",
+                triggerType: "RecordAfterSave",
+                object: "Account"
+              }
+            },
+          },
+        } as Partial<ParsedFlow> as ParsedFlow;
+
+        const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
+        expect(ruleResult.occurs).toBe(false);
+      });
+    });
+
+    describe("when using inputReference as lookup element", () => {
+      it("should trigger when inferred type matches inputReference", () => {
+        const testData: ParsedFlow = {
+          flow: {
+            elements: [
+              {
+                element: {
+                  object: "Case",
+                },
+                metaType: "node",
+                name: "lookupElement",
+                subtype: "recordLookups",
+              },
+              {
+                element: {
+                  inputReference: "lookupElement",
+                },
+                metaType: "node",
+                subtype: "recordUpdates",
+              },
+            ],
+            startNode: {
+              element: {
+                object: "Case",
+                recordTriggerType: "CreateAndUpdate",
+                triggerType: "RecordAfterSave",
+              }
+            },
+          },
+        } as Partial<ParsedFlow> as ParsedFlow;
+
+        const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
+        expect(ruleResult.occurs).toBe(true);
+      });
+
+      it("should not trigger when no matching inferred reference", () => {
+        const testData: ParsedFlow = {
+          flow: {
+            elements: [
+              {
+                element: {
+                  object: "Case",
+                },
+                metaType: "node",
+                name: "lookupElement",
+                subtype: "recordLookups",
+              },
+              {
+                element: {
+                  inputReference: "SomethingElse",
+                },
+                metaType: "node",
+                subtype: "recordUpdates",
+              },
+            ],
+            startNode: {
+              element: {
+                object: "Case",
+                recordTriggerType: "CreateAndUpdate",
+                triggerType: "RecordAfterSave",
+              }
+            },
+          },
+        } as Partial<ParsedFlow> as ParsedFlow;
+
+        const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
+        expect(ruleResult.occurs).toBe(false);
+      });
+    });
+  });
+});

package/tests/SOQLQueryInLoop.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "@jest/globals";
+import * as path from "path";
+
+import * as core from "../src";
+
+describe("SOQLQueryInLoop ", () => {
+  const example_uri = path.join(__dirname, "../../../example-flows/force-app/demo/SOQL_Query_In_A_Loop.flow-meta.xml");
+
+  const config = {
+    ruleMode: "isolated",
+    rules: {
+      SOQLQueryInLoop: {
+        severity: "error",
+      },
+    },
+  };
+
+  it("there should be one result for the rule SOQLQueryInLoop", async () => {
+    const flows = await core.parse([example_uri]);
+    const results: core.ScanResult[] = core.scan(flows, config);
+    const SOQLQueryInLoop = results[0].ruleResults.find(
+      (rule) => rule.occurs && rule.ruleName === "SOQLQueryInLoop"
+    );
+    expect(SOQLQueryInLoop?.occurs).toBe(true);
+  });
+
+  it("there should be no result for the rule SOQLQueryInLoop", async () => {
+    const flows = await core.parse([example_uri]);
+    const results: core.ScanResult[] = core.scan(flows, config);
+    const occurringResults = results[0].ruleResults.filter((rule) => rule.occurs);
+    expect(occurringResults).toEqual(expect.not.arrayContaining(["SOQLQueryInLoop"]));
+  });
+});

package/tests/SameRecordFieldUpdates.test.ts

@@ -0,0 +1,205 @@
+import { ParsedFlow } from "../src/main/models/ParsedFlow";
+import { SameRecordFieldUpdates } from "../src/main/rules/SameRecordFieldUpdates";
+import { RuleResult, Flow, parse, scan, ScanResult } from "../src";
+import * as path from "path";
+
+import { describe, it, expect } from "@jest/globals";
+
+describe("SameRecordFieldUpdates", () => {
+  const rule = new SameRecordFieldUpdates();
+
+  it("should flag same record updates on before context flows", async () => {
+    const testData: ParsedFlow = {
+      flow: {
+        status: "Active",
+        startNode: {
+          element: {
+            recordTriggerType: "Create",
+            triggerType: "RecordBeforeSave",
+            object: "Account",
+            connector: { targetReference: "Update_triggering_records" },
+            locationX: "50",
+            locationY: "0",
+          }
+        },
+        elements: [
+          {
+            element: {
+              description: "test",
+              name: "Update_triggering_records",
+              label: "Update triggering records",
+              locationX: "176",
+              locationY: "287",
+              inputAssignments: { field: "Active__c", value: { stringValue: "Yes" } },
+              inputReference: "$Record",
+            },
+            subtype: "recordUpdates",
+            metaType: "node",
+            connectors: [],
+            name: "Update_triggering_records",
+            locationX: "176",
+            locationY: "287",
+          }
+        ],
+      },
+    } as unknown as Partial<ParsedFlow> as ParsedFlow;
+
+    const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
+
+    expect(ruleResult.occurs).toBe(true);
+  });
+
+  it("should not flag same record updates on after context flows", async () => {
+    const testData: ParsedFlow = {
+      flow: {
+        status: "Active",
+        startNode: {
+          element: {
+            recordTriggerType: "Create",
+            triggerType: "RecordAfterSave",
+            object: "Account",
+            connector: { targetReference: "Update_triggering_records" },
+            locationX: "50",
+            locationY: "0",
+          }
+        },
+        elements: [
+          {
+            element: {
+              description: "test",
+              name: "Update_triggering_records",
+              label: "Update triggering records",
+              locationX: "176",
+              locationY: "287",
+              inputAssignments: { field: "Active__c", value: { stringValue: "Yes" } },
+              inputReference: "$Record",
+            },
+            subtype: "recordUpdates",
+            metaType: "node",
+            connectors: [],
+            name: "Update_triggering_records",
+            locationX: "176",
+            locationY: "287",
+          }
+        ],
+      },
+    } as unknown as Partial<ParsedFlow> as ParsedFlow;
+
+    const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
+
+    expect(ruleResult.occurs).toBe(false);
+  });
+
+  it("should trigger from default configuration on store", async () => {
+    const example_uri1 = path.join(__dirname, "../../../example-flows/force-app/demo/Same_Record_Field_Updates.flow-meta.xml");
+    const flows = await parse([example_uri1]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {},
+      exceptions: {},
+    };
+    const results: ScanResult[] = scan(flows, ruleConfig);
+    const scanResults = results.pop();
+
+    const foundRule = scanResults?.ruleResults.find((rule) => {
+      return rule.ruleDefinition.name === "SameRecordFieldUpdates";
+    });
+    expect(foundRule?.occurs).toBe(true);
+  });
+
+  it("should trigger when opt-in configuration", async () => {
+    const example_uri1 = path.join(__dirname, "../../../example-flows/force-app/demo/Same_Record_Field_Updates.flow-meta.xml");
+    const flows = await parse([example_uri1]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        SameRecordFieldUpdates: {
+          severity: "error",
+        },
+      },
+      exceptions: {},
+    };
+    const results: ScanResult[] = scan(flows, ruleConfig);
+    const scanResults = results.pop();
+
+    const expectedRule = scanResults?.ruleResults.find(
+      (rule) => rule.ruleName === "SameRecordFieldUpdates"
+    );
+    expect(expectedRule).toBeTruthy();
+    expect(expectedRule?.occurs).toBe(true);
+  });
+
+  it("should not error when start element is not existing", async () => {
+    const testData: ParsedFlow = {
+      flow: {
+        status: "Active",
+        elements: [
+          {
+            element: {
+              description: "test",
+              name: "Update_triggering_records",
+              label: "Update triggering records",
+              locationX: "176",
+              locationY: "287",
+              inputAssignments: { field: "Active__c", value: { stringValue: "Yes" } },
+              inputReference: "$Record",
+            },
+            subtype: "recordUpdates",
+            metaType: "node",
+            connectors: [],
+            name: "Update_triggering_records",
+            locationX: "176",
+            locationY: "287",
+          },
+          {
+            element: {
+              locationX: "50",
+              locationY: "0",
+              connector: { targetReference: "Update_triggering_records" },
+              object: "Account",
+              recordTriggerType: "Create",
+              triggerType: "RecordBeforeSave",
+            },
+            subtype: "start",
+            metaType: "node",
+            connectors: [
+              {
+                element: { targetReference: "Update_triggering_records" },
+                processed: false,
+                type: "connector",
+                reference: "Update_triggering_records",
+              },
+            ],
+            name: "flowstart",
+            locationX: "50",
+            locationY: "0",
+          },
+        ],
+      },
+    } as Partial<ParsedFlow> as ParsedFlow;
+
+    const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
+
+    expect(ruleResult.occurs).toBe(false);
+  });
+
+  it("should not error when elements are missing", async () => {
+    const testData: ParsedFlow = {
+      flow: {
+        status: "Active",
+        start: {
+          locationX: "50",
+          locationY: "0",
+          connector: { targetReference: "Update_triggering_records" },
+          object: "Account",
+          recordTriggerType: "Create",
+          triggerType: "RecordBeforeSave",
+        },
+      },
+    } as Partial<ParsedFlow> as ParsedFlow;
+
+    const ruleResult: RuleResult = rule.execute(testData.flow as Flow);
+
+    expect(ruleResult.occurs).toBe(false);
+  });
+});

package/tests/SanityTest.test.ts

@@ -0,0 +1,15 @@
+import * as core from "../src";
+
+test("core exports sanity", () => {
+  expect(core.scan).toBeDefined();
+  expect(core.parse).toBeDefined();
+});
+
+describe('UMD Global', () => {
+  it('exposes exports', () => {
+    const scanner = global.lightningflowscanner;
+    expect(scanner).toBeDefined();
+    expect(typeof scanner.scan).toBe('function');
+    expect(scanner.Flow).toBeDefined();
+  });
+});

package/tests/TransformInsteadOfLoop.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "@jest/globals";
+import * as path from "path";
+import * as core from "../src";
+
+describe("TransformInsteadOfLoop", () => {
+  const violating_uri = path.join(
+    __dirname,
+    "../../../example-flows/force-app/testing/Loop_Assignment_Pattern.flow-meta.xml"
+  );
+
+  it("should flag loop that connects directly to assignment", async () => {
+    const flows = await core.parse([violating_uri]);
+    expect(flows.length).toBeGreaterThan(0);
+    
+    const ruleConfig = {
+      betaMode: true,
+      ruleMode: "isolated",
+      rules: {
+        TransformInsteadOfLoop: {
+          severity: "note"
+        }
+      }
+    };
+    
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    expect(results.length).toBeGreaterThan(0);
+    
+    const ruleResult = results[0].ruleResults.find(r => r.ruleName === "TransformInsteadOfLoop");
+    expect(ruleResult).toBeDefined();
+    expect(ruleResult.occurs).toBe(true);
+    expect(ruleResult.details.length).toBeGreaterThan(0);
+  });
+});

package/tests/TriggerOrder.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "@jest/globals";
+import { Flow, RuleResult, scan, ScanResult } from "../src";
+import { ParsedFlow } from "../src/main/models/ParsedFlow";
+import { TriggerOrder } from "../src/main/rules/TriggerOrder";
+
+describe("TriggerOrder", () => {
+  it("should not trigger from default configuration on store", async () => {
+    const ruleConfig = {
+      ruleMode: "isolated",
+      exceptions: {},
+      rules: {
+        FlowDescription: {
+          severity: "error",
+        },
+      },
+    };
+    const flows: ParsedFlow[] = [
+      {
+        flow: {
+          status: "Active",
+          type: "AutoLaunchedFlow",
+          startNode: {
+            element: {
+              triggerType: "RecordAfterSave",
+              object: "Account"
+            }
+          }
+        },
+        type: "AutoLaunchedFlow",
+      } as unknown as Partial<ParsedFlow> as ParsedFlow,
+    ];
+    const results: ScanResult[] = scan(flows, ruleConfig);
+    const scanResults = results.pop();
+
+    const ruleResults = scanResults?.ruleResults.find((rule) => {
+      return rule.ruleDefinition.name === "TriggerOrder";
+    });
+    expect(ruleResults).toBeFalsy();
+  });
+
+  it("should trigger when opt-in configuration", async () => {
+    const flows: ParsedFlow[] = [
+      {
+        flow: {
+          status: "Active",
+          type: "AutoLaunchedFlow",
+          startNode: {
+            element: {
+              object: "Account",
+              triggerType: "RecordAfterSave"
+            }
+          }
+        },
+      } as unknown as Partial<ParsedFlow> as ParsedFlow,
+    ];
+
+    const ruleConfig = {
+      exceptions: {},
+      rules: {
+        ruleMode: "isolated",
+        TriggerOrder: {
+          severity: "error",
+        },
+      },
+    };
+    const results: ScanResult[] = scan(flows, ruleConfig);
+    const scanResults = results.pop();
+
+    const expectedRule = scanResults?.ruleResults.find((rule) => rule.ruleName === "TriggerOrder");
+    expect(expectedRule).toBeTruthy();
+    expect(expectedRule?.occurs).toBe(true);
+    expect(expectedRule?.details[0].details).toEqual({ expression: "10, 20, 30 ..." });
+  });
+
+  it("should flag trigger order when not present", async () => {
+    const testData: ParsedFlow = {
+      flow: {
+        status: "Active",
+        type: "AutoLaunchedFlow",
+        startNode: {
+          element: {
+            object: "Account",
+            triggerType: "RecordAfterSave"
+          }
+        }
+      },
+    } as unknown as Partial<ParsedFlow> as ParsedFlow;
+
+    const ruleResult: RuleResult = new TriggerOrder().execute(testData.flow as Flow);
+
+    expect(ruleResult.occurs).toBeTruthy();
+  });
+
+  it("should not flag trigger order when present", async () => {
+    const testData: ParsedFlow = {
+      flow: {
+        status: "Active",
+        type: "AutoLaunchedFlow",
+        triggerOrder: 10,
+        startNode: {
+          element: {
+            object: "Account",
+          }
+        }
+      },
+    } as Partial<ParsedFlow> as ParsedFlow;
+
+    const ruleResult: RuleResult = new TriggerOrder().execute(testData.flow as Flow);
+
+    expect(ruleResult.occurs).toBeFalsy();
+  });
+});

package/tests/UnconnectedElement.test.ts

@@ -0,0 +1,76 @@
+import * as core from "../src";
+import * as path from "path";
+import { parse } from "../src/main/libs/ParseFlows";
+import { ParsedFlow } from "../src/main/models/ParsedFlow";
+import { UnconnectedElement } from "../src/main/rules/UnconnectedElement";
+import { describe, it, expect } from "@jest/globals";
+
+describe("UnconnectedElement", () => {
+  const unconnectedElementRule: UnconnectedElement = new UnconnectedElement();
+  it("there should be checks for unconnected element", async () => {
+    const connectedElementTestFile = path.join(
+      __dirname,
+      "../../../example-flows/force-app/demo/Unreachable_Element.flow-meta.xml"
+    );
+    const parsed: ParsedFlow = (await parse([connectedElementTestFile])).pop() as ParsedFlow;
+    const ruleResult: core.RuleResult = unconnectedElementRule.execute(parsed.flow as core.Flow);
+    expect(ruleResult.occurs).toBe(true);
+    expect(ruleResult.details).not.toHaveLength(0);
+    ruleResult.details.forEach((detail) => {
+      expect(detail.name).toBe("unused_assignment");
+    });
+  });
+  it("async path there should be checks for unconnected element", async () => {
+    const connectedElementTestFile = path.join(
+      __dirname,
+      "../../../example-flows/force-app/testing/Unconnected_Element_Async.flow-meta.xml"
+    );
+    const parsed: ParsedFlow = (await parse([connectedElementTestFile])).pop() as ParsedFlow;
+    const ruleResult: core.RuleResult = unconnectedElementRule.execute(parsed.flow as core.Flow);
+    expect(ruleResult.occurs).toBe(true);
+    ruleResult.details.forEach((ruleDetail) => {
+      expect(ruleDetail.name).toBe("UnconnectedElementTestOnAsync");
+    });
+  });
+  it("should fix the unconnected element error", async () => {
+    const connectedElementTestFile = path.join(
+      __dirname,
+      "../../../example-flows/force-app/demo/Unreachable_Element.flow-meta.xml"
+    );
+    const flows = await core.parse([connectedElementTestFile]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      rules: {
+        UnconnectedElement: {
+          severity: "error",
+        },
+      },
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const fixedResults: core.ScanResult[] = core.fix(results);
+    const fixedFlow: ParsedFlow = new ParsedFlow(connectedElementTestFile, fixedResults[0].flow);
+    const newResults: core.ScanResult[] = core.scan([fixedFlow], ruleConfig);
+    const fixedResultsOccurring = newResults[0].ruleResults.filter((rule) => rule.occurs);
+    expect(fixedResultsOccurring).toHaveLength(0);
+  });
+  it("should not include enriched details with detailLevel simple", async () => {
+    const testFile = path.join(
+      __dirname,
+      "../../../example-flows/force-app/demo/Unreachable_Element.flow-meta.xml"
+    );
+    const flows = await core.parse([testFile]);
+    const ruleConfig = {
+      ruleMode: "isolated",
+      detailLevel: "simple",
+    };
+    const results: core.ScanResult[] = core.scan(flows, ruleConfig);
+    const ruleResult = results[0].ruleResults.find((r) => r.ruleName === "UnconnectedElement");
+    expect(ruleResult).toBeDefined();
+    expect(ruleResult.occurs).toBe(true);
+    expect(ruleResult.details).not.toHaveLength(0);
+    ruleResult.details.forEach((detail) => {
+      expect(detail.name).toBe("unused_assignment");
+      expect(detail.details).toBeUndefined();
+    });
+  });
+});