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

package/.husky/pre-commit

@@ -0,0 +1 @@
+npm run precommit

package/.husky/pre-push

@@ -0,0 +1 @@
+npm run prepush

package/.prettierignore

@@ -0,0 +1,5 @@
+assets/example-flows/**
+out/**
+tests/**/*.test.ts
+jest.config.ts
+vite.config.ts

package/.swcrc

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://swc.rs/schema.json",
+  "sourceMaps": false,
+  "module": {
+    "type": "commonjs",
+    "strictMode": true,
+    "noInterop": false,
+    "resolveFully": true
+  },
+  "jsc": {
+    "externalHelpers": false,
+    "target": "es2015",
+    "parser": {
+      "syntax": "typescript",
+      "tsx": true,
+      "decorators": true,
+      "dynamicImport": true
+    },
+    "transform": {
+      "legacyDecorator": true,
+      "decoratorMetadata": false
+    },
+    "keepClassNames": true
+  },
+  "minify": false  // Disable for now; re-enable post-debug if needed for smaller JS
+}

package/eslint.config.mjs

@@ -0,0 +1,36 @@
+import deMorgan from "eslint-plugin-de-morgan";
+import github from "eslint-plugin-github";
+import pluginJest from "eslint-plugin-jest";
+import perfectionist from "eslint-plugin-perfectionist";
+import sonarjs from "eslint-plugin-sonarjs";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default [
+  { languageOptions: { globals: globals.browser } },
+  ...tseslint.configs.recommended,
+  {
+    files: ["tests/*.test.ts"],
+    languageOptions: {
+      globals: pluginJest.environments.globals.globals,
+    },
+    plugins: { jest: pluginJest },
+    rules: {
+      "jest/no-alias-methods": "error",
+      "jest/no-disabled-tests": "warn",
+      "jest/no-focused-tests": "error",
+      "jest/no-identical-title": "error",
+      "jest/prefer-to-have-length": "warn",
+      "jest/valid-expect": "error",
+    },
+  },
+  {
+    ignores: ["jest.config.ts", "assets/example-flows/**"],
+  },
+  perfectionist.configs["recommended-alphabetical"],
+  perfectionist.configs["recommended-line-length"],
+  perfectionist.configs["recommended-natural"],
+  sonarjs.configs.recommended,
+  deMorgan.configs.recommended,
+  ...github.getFlatConfigs().typescript,
+];

package/jest.config.cjs

@@ -0,0 +1,32 @@
+module.exports = {
+  automock: false,
+  clearMocks: true,
+  collectCoverage: true,
+  coverageDirectory: "coverage",
+  coverageProvider: "v8",
+  coverageReporters: ["json", "text", "lcov"],
+  modulePathIgnorePatterns: ["./jest.config.cjs", "./out/"],
+  setupFilesAfterEnv: ["<rootDir>/jest.env-setup.js"],
+  testEnvironment: "node",
+  testPathIgnorePatterns: ["/node_modules/"],
+  transform: {
+    "^.+\\.(t|j)sx?$": [
+      "@swc-node/jest",
+      {
+        module: "commonjs",
+        swc: {
+          jsc: {
+            target: "es2020",
+            parser: {
+              syntax: "typescript",
+              tsx: false,
+            },
+          },
+          sourceMaps: "inline",
+          minify: false,
+        },
+      },
+    ],
+  },
+  transformIgnorePatterns: ["/node_modules/", "\\.pnp\\.[^\\/]+$"],
+};

package/jest.env-setup.js

@@ -0,0 +1,101 @@
+const fs = require("fs");
+const path = require("path");
+
+module.exports = () => {
+  if (!process.env.UMD_PATH) {
+    console.log("UMD Setup: No UMD_PATH—skipping (Node-only mode)");
+    return;
+  }
+
+  const umdFilePath = path.resolve(process.env.UMD_PATH);
+
+  if (!fs.existsSync(umdFilePath)) {
+    console.warn("UMD Setup: File not found at", umdFilePath, "—skipping.");
+    return;
+  }
+
+  let umdCode = fs.readFileSync(umdFilePath, "utf8");
+  const fastXmlParser = require("fast-xml-parser");
+
+  // Vite UMD pattern: (function(global, factory) { ... })(this, function(exports, dependency) { ... });
+  // We need to extract and execute the factory function
+
+  // Try to match Vite's UMD pattern more flexibly
+  const viteUmdMatch = umdCode.match(
+    /\(function\s*\([^,]+,\s*(\w+)\)\s*\{[\s\S]*?\}\)\s*\(this,\s*function\s*\((\w+)(?:,\s*(\w+))?\)\s*\{([\s\S]+)\}\s*\)\s*;?\s*$/
+  );
+
+  if (viteUmdMatch) {
+    const factoryBody = viteUmdMatch[4];
+    const exportsParam = viteUmdMatch[2];
+    const depParam = viteUmdMatch[3];
+
+    try {
+      // Create the factory function with proper parameters
+      const factoryFn = depParam
+        ? new Function(exportsParam, depParam, factoryBody)
+        : new Function(exportsParam, factoryBody);
+
+      // Create exports object and invoke factory
+      const exports = {};
+      if (depParam) {
+        factoryFn(exports, fastXmlParser);
+      } else {
+        factoryFn(exports);
+      }
+
+      // Assign to global
+      global.lightningflowscanner = exports;
+
+      if (Object.keys(exports).length === 0) {
+        console.error("UMD Setup: WARNING - exports object is empty!");
+      }
+    } catch (e) {
+      console.error("UMD Factory error:", e.message);
+      console.error("Stack:", e.stack);
+    }
+  } else {
+    // Fallback: Try direct execution approach
+
+    try {
+      // Create a mock global/window context
+      const mockGlobal = {};
+      const mockFactory = new Function(
+        "global",
+        "factory",
+        `
+        return (function(root, factoryFn) {
+          if (typeof exports === 'object' && typeof module !== 'undefined') {
+            factoryFn(exports, require('fast-xml-parser'));
+          } else {
+            factoryFn((root.lightningflowscanner = {}), root.fastXmlParser);
+          }
+        })(global, factory);
+      `
+      );
+
+      // Execute in controlled context
+      const vm = require("vm");
+      const sandbox = {
+        exports: {},
+        require: (id) => (id === "fast-xml-parser" ? fastXmlParser : require(id)),
+        module: { exports: {} },
+        console: console,
+      };
+
+      vm.runInNewContext(umdCode, sandbox);
+
+      // Check what got exported
+      const exports = sandbox.exports.default || sandbox.exports || sandbox.module.exports;
+
+      if (exports && Object.keys(exports).length > 0) {
+        global.lightningflowscanner = exports;
+      } else {
+        console.error("UMD Setup: Direct execution failed - no exports found");
+      }
+    } catch (e) {
+      console.error("UMD Direct execution error:", e.message);
+      console.error("Stack:", e.stack.slice(0, 400));
+    }
+  }
+};

package/lint-staged.config.mjs

@@ -0,0 +1,8 @@
+import micromatch from "micromatch";
+
+const isNotExampleFlows = (files) => micromatch.not(files, ["assets/example-flows/**"]);
+
+export default {
+  "**/*.{js,json,md,xml,yaml,yml}": (files) =>
+    isNotExampleFlows(files).map((f) => `prettier --write "${f}"`),
+};

package/{main → out/main}/interfaces/IRuleDefinition.d.ts

@@ -1,6 +1,5 @@
 import { Flow, RuleResult } from "../internals/internals";
 export interface IRuleDefinition {
-    autoFixable: boolean;
     description: string;
     docRefs: Array<{
         label: string;

package/{main → out/main}/internals/internals.d.ts

@@ -14,5 +14,5 @@ import { RuleCommon } from "../models/RuleCommon";
 import { RuleResult } from "../models/RuleResult";
 import { ScanResult } from "../models/ScanResult";
 import { Violation } from "../models/Violation";
-export { FlatViolation, FlowAttribute, FlowElement, FlowNode, FlowType, FlowVariable, FlowResource, Flow, Compiler, ScanResult, RuleResult, Violation, RuleCommon, ParsedFlow, };
-export type { IRuleDefinition, IRulesConfig };
+export { FlowAttribute, FlowElement, FlowNode, FlowType, FlowVariable, FlowResource, Flow, Compiler, ScanResult, RuleResult, Violation, RuleCommon, ParsedFlow, };
+export type { IRuleDefinition, IRulesConfig, FlatViolation };

package/{main → out/main}/internals/internals.js

@@ -12,9 +12,6 @@ _export(exports, {
     get Compiler () {
         return _Compiler.Compiler;
     },
-    get FlatViolation () {
-        return _FlatViolation.FlatViolation;
-    },
     get Flow () {
         return _Flow.Flow;
     },
@@ -53,7 +50,6 @@ _export(exports, {
     }
 });
 const _Compiler = require("../libs/Compiler");
-const _FlatViolation = require("../models/FlatViolation");
 const _Flow = require("../models/Flow");
 const _FlowAttribute = require("../models/FlowAttribute");
 const _FlowElement = require("../models/FlowElement");

package/{main → out/main}/models/RuleCommon.d.ts

@@ -1,7 +1,6 @@
 import { RuleInfo } from "./RuleInfo";
 import * as core from "../internals/internals";
 export declare abstract class RuleCommon {
-    autoFixable: boolean;
     description: string;
     docRefs: Array<{
         label: string;

package/{main → out/main}/models/RuleCommon.js

@@ -86,10 +86,9 @@ let RuleCommon = class RuleCommon {
         return suppressions.has(name);
     }
     constructor(info, optional){
-        _define_property(this, "autoFixable", void 0);
         _define_property(this, "description", void 0);
         _define_property(this, "docRefs", []);
-        _define_property(this, "isConfigurable", void 0);
+        _define_property(this, "isConfigurable", void 0); // Auto-detected by checking if the implemented check() method actually uses "options."
         _define_property(this, "label", void 0);
         _define_property(this, "name", void 0);
         _define_property(this, "severity", void 0);
@@ -102,8 +101,13 @@ let RuleCommon = class RuleCommon {
         this.description = info.description;
         this.uri = `https://github.com/Lightning-Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/${info.name}.ts`;
         this.docRefs = info.docRefs;
-        this.isConfigurable = info.isConfigurable;
-        this.autoFixable = info.autoFixable;
+        const checkImpl = this.check;
+        if (typeof checkImpl === "function") {
+            const source = checkImpl.toString();
+            this.isConfigurable = /options[.\?]/.test(source);
+        } else {
+            this.isConfigurable = false;
+        }
         var _optional_severity;
         this.severity = (_optional_severity = optional === null || optional === void 0 ? void 0 : optional.severity) !== null && _optional_severity !== void 0 ? _optional_severity : "error";
         this.suppressionElement = info.suppressionElement;

package/{main → out/main}/models/RuleInfo.d.ts

@@ -7,11 +7,6 @@ export type RuleDefinitionExpression = {
  * Represents a rule metadata; this contains properties to describe the rule
  */
 export declare class RuleInfo {
-    /**
-     * Indicates whether the rule can be automatically fixed.
-     * When the rule is autofixable, implement @see {AutoFixable}
-     */
-    autoFixable: boolean;
     /**
      * A human-readable description of the rule.
      */
@@ -23,16 +18,6 @@ export declare class RuleInfo {
         label: string;
         path: string;
     }>;
-    /**
-     * Specifies if the rule's behavior can be configured.
-     * When configurable, execute should take in a second parameter @see RuleDefinitionExpression
-     * @example
-     * ```typescript
-     * public execute(flow: core.Flow, options?: { expression: string }): core.RuleResult {
-     *   // your rule
-     * }
-     */
-    isConfigurable: boolean;
     /**
      * The display label for the rule.
      * This property is being displayed on sf cli and on vsce

package/{main → out/main}/models/RuleInfo.js

@@ -24,25 +24,12 @@ function _define_property(obj, key, value) {
 let RuleInfo = class RuleInfo {
     constructor(){
         /**
-   * Indicates whether the rule can be automatically fixed.
-   * When the rule is autofixable, implement @see {AutoFixable}
-   */ _define_property(this, "autoFixable", void 0);
-        /**
    * A human-readable description of the rule.
    */ _define_property(this, "description", void 0);
         /**
    * An array of documentation references related to the rule.
    */ _define_property(this, "docRefs", void 0);
         /**
-   * Specifies if the rule's behavior can be configured.
-   * When configurable, execute should take in a second parameter @see RuleDefinitionExpression
-   * @example
-   * ```typescript
-   * public execute(flow: core.Flow, options?: { expression: string }): core.RuleResult {
-   *   // your rule
-   * }
-   */ _define_property(this, "isConfigurable", void 0);
-        /**
    * The display label for the rule.
    * This property is being displayed on sf cli and on vsce
    */ _define_property(this, "label", void 0);

package/{main → out/main}/rules/APIVersion.js

@@ -80,9 +80,7 @@ let APIVersion = class APIVersion extends _RuleCommon.RuleCommon {
             label: "Outdated API Version",
             description: "Introducing newer API components may lead to unexpected issues with older versions of Flows, as they might not align with the underlying mechanics. Starting from API version 50.0, the 'Api Version' attribute has been readily available on the Flow Object. To ensure smooth operation and reduce discrepancies between API versions, it is strongly advised to regularly update and maintain them.",
             supportedTypes: _internals.FlowType.allTypes(),
-            docRefs: [],
-            isConfigurable: true,
-            autoFixable: false
+            docRefs: []
         });
     }
 };

package/{main → out/main}/rules/ActionCallsInLoop.js

@@ -19,7 +19,6 @@ let ActionCallsInLoop = class ActionCallsInLoop extends _LoopRuleCommon.LoopRule
     }
     constructor(){
         super({
-            autoFixable: false,
             description: "To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilize a single action call containing a collection variable at the end of the loop.",
             docRefs: [
                 {
@@ -27,7 +26,6 @@ let ActionCallsInLoop = class ActionCallsInLoop extends _LoopRuleCommon.LoopRule
                     path: "https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_classes_annotation_InvocableMethod.htm"
                 }
             ],
-            isConfigurable: false,
             label: "Action Call In Loop",
             name: "ActionCallsInLoop",
             supportedTypes: _internals.FlowType.backEndTypes

package/{main → out/main}/rules/AutoLayout.js

@@ -69,9 +69,7 @@ let AutoLayout = class AutoLayout extends _RuleCommon.RuleCommon {
             label: "Auto-Layout Mode",
             description: "With Canvas Mode set to Auto-Layout, Elements are spaced, connected, and aligned automatically, keeping your Flow neatly organized thus saving you time.",
             supportedTypes: _internals.FlowType.allTypes(),
-            docRefs: [],
-            isConfigurable: true,
-            autoFixable: false
+            docRefs: []
         });
     }
 };

package/{main → out/main}/rules/CopyAPIName.js

@@ -63,9 +63,7 @@ let CopyAPIName = class CopyAPIName extends _RuleCommon.RuleCommon {
             label: "Copy API Name",
             description: "Maintaining multiple elements with a similar name, like 'Copy_X_Of_Element,' can diminish the overall readability of your Flow. When copying and pasting these elements, it's crucial to remember to update the API name of the newly created copy.",
             supportedTypes: _internals.FlowType.allTypes(),
-            docRefs: [],
-            isConfigurable: false,
-            autoFixable: false
+            docRefs: []
         });
     }
 };

package/{main → out/main}/rules/CyclomaticComplexity.js

@@ -96,9 +96,7 @@ let CyclomaticComplexity = class CyclomaticComplexity extends _RuleCommon.RuleCo
                     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"
                 }
-            ],
-            isConfigurable: true,
-            autoFixable: false
+            ]
         }, {
             severity: "note"
         }), _define_property(this, "defaultThreshold", 25), _define_property(this, "cyclomaticComplexityUnit", 0);

package/{main → out/main}/rules/DMLStatementInLoop.js

@@ -20,7 +20,6 @@ let DMLStatementInLoop = class DMLStatementInLoop extends _LoopRuleCommon.LoopRu
     }
     constructor(){
         super({
-            autoFixable: false,
             description: "To prevent exceeding Apex governor limits, it is advisable to consolidate all your database operations, including record creation, updates, or deletions, at the conclusion of the flow.",
             docRefs: [
                 {
@@ -28,7 +27,6 @@ let DMLStatementInLoop = class DMLStatementInLoop extends _LoopRuleCommon.LoopRu
                     path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5"
                 }
             ],
-            isConfigurable: false,
             label: "DML Statement In A Loop",
             name: "DMLStatementInLoop",
             supportedTypes: _internals.FlowType.backEndTypes

package/{main → out/main}/rules/DuplicateDMLOperation.js

@@ -136,9 +136,7 @@ let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.Rule
             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: _internals.FlowType.visualTypes,
-            docRefs: [],
-            isConfigurable: false,
-            autoFixable: false
+            docRefs: []
         });
     }
 };

package/{main → out/main}/rules/FlowDescription.js

@@ -63,10 +63,8 @@ let FlowDescription = class FlowDescription extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
-            autoFixable: false,
             description: "Descriptions play a vital role in documentation. We highly recommend including details about where they are used and their intended purpose.",
             docRefs: [],
-            isConfigurable: false,
             label: "Missing Flow Description",
             name: "FlowDescription",
             supportedTypes: [

package/{main → out/main}/rules/FlowName.js

@@ -66,7 +66,6 @@ let FlowName = class FlowName extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
-            autoFixable: false,
             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: [
                 {
@@ -74,7 +73,6 @@ let FlowName = class FlowName extends _RuleCommon.RuleCommon {
                     path: "https://www.linkedin.com/posts/stephen-n-church_naming-your-flows-this-is-more-critical-activity-7099733198175158274-1sPx"
                 }
             ],
-            isConfigurable: true,
             label: "Flow Naming Convention",
             name: "FlowName",
             supportedTypes: _internals.FlowType.allTypes()

package/{main → out/main}/rules/GetRecordAllFields.js

@@ -66,7 +66,6 @@ let GetRecordAllFields = class GetRecordAllFields extends _RuleCommon.RuleCommon
     }
     constructor(){
         super({
-            autoFixable: false,
             description: "Following the principle of least privilege (PoLP), avoid using Get Records with 'Automatically store all fields' unless necessary.",
             docRefs: [
                 {
@@ -78,7 +77,6 @@ let GetRecordAllFields = class GetRecordAllFields extends _RuleCommon.RuleCommon
                     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"
                 }
             ],
-            isConfigurable: false,
             label: "Get Record All Fields",
             name: "GetRecordAllFields",
             supportedTypes: _internals.FlowType.allTypes()

package/{main → out/main}/rules/HardcodedId.js

@@ -71,9 +71,7 @@ let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
                     label: "Don't hard code Record Type IDs in Flow. By Stephen Church.",
                     path: "https://www.linkedin.com/feed/update/urn:li:activity:6947530300012826624/"
                 }
-            ],
-            isConfigurable: false,
-            autoFixable: false
+            ]
         });
     }
 };

package/{main → out/main}/rules/HardcodedUrl.js

@@ -18,7 +18,6 @@ let HardcodedUrl = class HardcodedUrl extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
-            autoFixable: false,
             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: [
                 {
@@ -30,7 +29,6 @@ let HardcodedUrl = class HardcodedUrl extends _RuleCommon.RuleCommon {
                     path: "https://admin.salesforce.com/blog/2021/why-you-should-avoid-hard-coding-and-three-alternative-solutions"
                 }
             ],
-            isConfigurable: false,
             label: "Hardcoded Url",
             name: "HardcodedUrl",
             supportedTypes: _internals.FlowType.allTypes()

package/{main → out/main}/rules/InactiveFlow.js

@@ -66,9 +66,7 @@ let InactiveFlow = class InactiveFlow extends _RuleCommon.RuleCommon {
             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: _internals.FlowType.allTypes(),
-            docRefs: [],
-            isConfigurable: false,
-            autoFixable: false
+            docRefs: []
         });
     }
 };

package/{main → out/main}/rules/MissingFaultPath.js

@@ -120,7 +120,6 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
     }
     constructor(){
         super({
-            autoFixable: false,
             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: [
                 {
@@ -128,7 +127,6 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
                     path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5"
                 }
             ],
-            isConfigurable: false,
             label: "Missing Fault Path",
             name: "MissingFaultPath",
             supportedTypes: [

package/{main → out/main}/rules/MissingMetadataDescription.js

@@ -65,10 +65,8 @@ let MissingMetadataDescription = class MissingMetadataDescription extends _RuleC
     }
     constructor(){
         super({
-            autoFixable: false,
             description: "Every element must have a meaningful description",
             docRefs: [],
-            isConfigurable: false,
             label: "Missing Metadata Description",
             name: "MissingMetadataDescription",
             supportedTypes: _internals.FlowType.allTypes()

package/{main → out/main}/rules/MissingNullHandler.js

@@ -130,10 +130,8 @@ let MissingNullHandler = class MissingNullHandler extends _RuleCommon.RuleCommon
     }
     constructor(){
         super({
-            autoFixable: false,
             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: [],
-            isConfigurable: false,
             label: "Missing Null Handler",
             name: "MissingNullHandler",
             supportedTypes: [

package/{main → out/main}/rules/ProcessBuilder.js

@@ -68,9 +68,7 @@ let ProcessBuilder = class ProcessBuilder extends _RuleCommon.RuleCommon {
                     label: "Process Builder Retirement",
                     path: "https://help.salesforce.com/s/articleView?id=000389396&type=1"
                 }
-            ],
-            isConfigurable: true,
-            autoFixable: false
+            ]
         });
     }
 };

package/{main → out/main}/rules/RecursiveAfterUpdate.js

@@ -101,7 +101,6 @@ let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCo
     }
     constructor(){
         super({
-            autoFixable: false,
             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: [
                 {
@@ -109,7 +108,6 @@ let RecursiveAfterUpdate = class RecursiveAfterUpdate extends _RuleCommon.RuleCo
                     path: "https://architect.salesforce.com/decision-guides/trigger-automation#Same_Record_Field_Updates"
                 }
             ],
-            isConfigurable: false,
             label: "Recursive After Update",
             name: "RecursiveAfterUpdate",
             supportedTypes: [

package/{main → out/main}/rules/SOQLQueryInLoop.js

@@ -18,7 +18,6 @@ let SOQLQueryInLoop = class SOQLQueryInLoop extends _LoopRuleCommon.LoopRuleComm
     }
     constructor(){
         super({
-            autoFixable: false,
             description: "To prevent exceeding Apex governor limits, it is advisable to consolidate all your SOQL queries at the conclusion of the flow.",
             docRefs: [
                 {
@@ -26,7 +25,6 @@ let SOQLQueryInLoop = class SOQLQueryInLoop extends _LoopRuleCommon.LoopRuleComm
                     path: "https://help.salesforce.com/s/articleView?id=sf.flow_prep_bestpractices.htm&type=5"
                 }
             ],
-            isConfigurable: false,
             label: "SOQL Query In A Loop",
             name: "SOQLQueryInLoop",
             supportedTypes: _internals.FlowType.backEndTypes

package/{main → out/main}/rules/SameRecordFieldUpdates.js

@@ -95,9 +95,7 @@ let SameRecordFieldUpdates = class SameRecordFieldUpdates extends _RuleCommon.Ru
                     label: "Learn about same record field updates",
                     path: "https://architect.salesforce.com/decision-guides/trigger-automation#Same_Record_Field_Updates"
                 }
-            ],
-            isConfigurable: false,
-            autoFixable: false
+            ]
         }, {
             severity: "warning"
         }), _define_property(this, "qualifiedRecordTriggerTypes", new Set([

package/{main → out/main}/rules/TriggerOrder.js

@@ -87,9 +87,7 @@ let TriggerOrder = class TriggerOrder extends _RuleCommon.RuleCommon {
                     label: "Learn more about flow ordering orchestration",
                     path: "https://architect.salesforce.com/decision-guides/trigger-automation#Ordering___Orchestration"
                 }
-            ],
-            isConfigurable: false,
-            autoFixable: false
+            ]
         }, {
             severity: "note"
         }), _define_property(this, "qualifiedRecordTriggerTypes", new Set([