@flow-scanner/lightning-flow-scanner-core 6.5.0 → 6.6.0

package/README.md

@@ -30,9 +30,9 @@
 <p>📌<strong>Tip:</strong> To link directly to a specific rule, use the full GitHub anchor link format. Example:</p>
 <p><em><a href="https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context">https://github.com/Flow-Scanner/lightning-flow-scanner-core#unsafe-running-context</a></em></p>
 
-> Want to code a new rule? → See [How to Write a Rule](docs/write-a-new-rule.md)
+> Want to code a new rule? → See [How to Write a Rule](docs/write-a-rule.md)
 
-### Action Calls In Loop(Beta)
+### Action Calls In Loop
 
 _[ActionCallsInLoop](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/ActionCallsInLoop.ts)_ - To prevent exceeding Apex governor limits, it is advisable to consolidate and bulkify your apex calls, utilizing a single action call containing a collection variable at the end of the loop.
 
@@ -88,6 +88,10 @@ _[MissingFaultPath](https://github.com/Flow-Scanner/lightning-flow-scanner-core/
 
 _[FlowDescription](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/FlowDescription.ts)_ - Descriptions play a vital role in documentation. We highly recommend including details about where flows are used and their intended purpose.
 
+### MissingMetadataDescription
+
+_[MissingMetadataDescription](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/MissingMetadataDescription.ts)_ – Flags Flow elements (Get Records, Assignments, Decisions, Actions, etc.) and metadata components (Variables, Formulas, Constants, Text Templates) that lack a description. Adding concise descriptions greatly improves readability, maintainability, and helps AI tools understand your automation intent.
+
 ### Missing Null Handler
 
 _[MissingNullHandler](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/rules/MissingNullHandler.ts)_ - When a **Get Records** operation finds no data, it returns `null`. Validate data by using a Decision element to check for a non‑null result.

package/index.d.ts

@@ -5,7 +5,7 @@ import { Compiler } from "./main/libs/Compiler";
 import { exportDetails } from "./main/libs/exportAsDetails";
 import { exportSarif } from "./main/libs/exportAsSarif";
 import { fix } from "./main/libs/FixFlows";
-import { getBetaRules, getRules } from "./main/libs/GetRuleDefinitions";
+import { getRules } from "./main/libs/GetRuleDefinitions";
 import { parse } from "./main/libs/ParseFlows";
 import { scan } from "./main/libs/ScanFlows";
 import { Flow } from "./main/models/Flow";
@@ -19,5 +19,5 @@ import { ParsedFlow } from "./main/models/ParsedFlow";
 import { RuleResult } from "./main/models/RuleResult";
 import { ScanResult } from "./main/models/ScanResult";
 import { Violation } from "./main/models/Violation";
-export { Compiler, exportDetails, exportSarif, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getBetaRules, getRules, parse, ParsedFlow, Violation, RuleResult, scan, ScanResult, };
+export { Compiler, exportDetails, exportSarif, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getRules, parse, ParsedFlow, Violation, RuleResult, scan, ScanResult, };
 export type { FlatViolation, IRuleDefinition, IRulesConfig };

package/index.js

@@ -54,9 +54,6 @@ _export(exports, {
     get fix () {
         return _FixFlows.fix;
     },
-    get getBetaRules () {
-        return _GetRuleDefinitions.getBetaRules;
-    },
     get getRules () {
         return _GetRuleDefinitions.getRules;
     },

package/main/libs/DynamicRule.d.ts

@@ -1,4 +1,4 @@
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class DynamicRule<T extends IRuleDefinition> {
-    constructor(className: string);
+    constructor(className: string, betaMode?: boolean);
 }

package/main/libs/DynamicRule.js

@@ -10,8 +10,8 @@ Object.defineProperty(exports, "DynamicRule", {
 });
 const _DefaultRuleStore = require("../store/DefaultRuleStore");
 let DynamicRule = class DynamicRule {
-    constructor(className){
-        if (!_DefaultRuleStore.DefaultRuleStore.hasOwnProperty(className) && _DefaultRuleStore.BetaRuleStore.hasOwnProperty(className)) {
+    constructor(className, betaMode = false){
+        if (betaMode && _DefaultRuleStore.BetaRuleStore.hasOwnProperty(className)) {
             return new _DefaultRuleStore.BetaRuleStore[className]();
         }
         return new _DefaultRuleStore.DefaultRuleStore[className]();

package/main/libs/GetRuleDefinitions.d.ts

@@ -1,5 +1,4 @@
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 import { IRulesConfig } from "../interfaces/IRulesConfig";
-export declare function getBetaRules(): IRuleDefinition[];
 export declare function GetRuleDefinitions(ruleConfig?: Map<string, unknown>, options?: IRulesConfig): IRuleDefinition[];
 export declare function getRules(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[];

package/main/libs/GetRuleDefinitions.js

@@ -12,18 +12,12 @@ _export(exports, {
     get GetRuleDefinitions () {
         return GetRuleDefinitions;
     },
-    get getBetaRules () {
-        return getBetaRules;
-    },
     get getRules () {
         return getRules;
     }
 });
 const _DefaultRuleStore = require("../store/DefaultRuleStore");
 const _DynamicRule = require("./DynamicRule");
-function getBetaRules() {
-    return getBetaDefinition();
-}
 function GetRuleDefinitions(ruleConfig, options) {
     const selectedRules = [];
     const includeBeta = (options === null || options === void 0 ? void 0 : options.betaMode) === true || (options === null || options === void 0 ? void 0 : options.betamode) === true;
@@ -36,10 +30,9 @@ function GetRuleDefinitions(ruleConfig, options) {
                 if (configuredSeverity && (configuredSeverity === "error" || configuredSeverity === "warning" || configuredSeverity === "note")) {
                     severity = configuredSeverity;
                 }
-                const matchedRule = new _DynamicRule.DynamicRule(ruleName);
-                if (configuredSeverity) {
-                    matchedRule.severity = severity;
-                }
+                // Pass betaMode to DynamicRule
+                const matchedRule = new _DynamicRule.DynamicRule(ruleName, includeBeta);
+                if (configuredSeverity) matchedRule.severity = severity;
                 selectedRules.push(matchedRule);
             } catch (error) {
                 console.log(error.message);
@@ -48,14 +41,15 @@ function GetRuleDefinitions(ruleConfig, options) {
     } else {
         // Load all defaults
         for(const rule in _DefaultRuleStore.DefaultRuleStore){
-            const matchedRule = new _DynamicRule.DynamicRule(rule);
+            const matchedRule = new _DynamicRule.DynamicRule(rule, includeBeta);
             selectedRules.push(matchedRule);
         }
     }
-    if (includeBeta && _DefaultRuleStore.BetaRuleStore && typeof _DefaultRuleStore.BetaRuleStore === 'object' && !Array.isArray(_DefaultRuleStore.BetaRuleStore)) {
+    // Optionally add beta-only rules that are not in defaults
+    if (includeBeta) {
         for(const betaRuleName in _DefaultRuleStore.BetaRuleStore){
             if (!selectedRules.some((r)=>r.name === betaRuleName)) {
-                const betaRule = new _DynamicRule.DynamicRule(betaRuleName);
+                const betaRule = new _DynamicRule.DynamicRule(betaRuleName, true);
                 selectedRules.push(betaRule);
             }
         }
@@ -71,10 +65,6 @@ function getRules(ruleNames, options) {
                 }
             ]));
         return GetRuleDefinitions(ruleSeverityMap, options);
-    } else {
-        return GetRuleDefinitions(undefined, options);
     }
-}
-function getBetaDefinition() {
-    return Object.values(_DefaultRuleStore.BetaRuleStore).map((rule)=>new rule());
+    return GetRuleDefinitions(undefined, options);
 }

package/main/libs/ScanFlows.js

@@ -40,9 +40,9 @@ function ScanFlows(flows, ruleOptions) {
         for (const [ruleName, config] of Object.entries(ruleOptions.rules)){
             ruleMap.set(ruleName, config);
         }
-        selectedRules = (0, _GetRuleDefinitions.GetRuleDefinitions)(ruleMap);
+        selectedRules = (0, _GetRuleDefinitions.GetRuleDefinitions)(ruleMap, ruleOptions);
     } else {
-        selectedRules = (0, _GetRuleDefinitions.GetRuleDefinitions)();
+        selectedRules = (0, _GetRuleDefinitions.GetRuleDefinitions)(undefined, ruleOptions);
     }
     const flowXmlCache = new Map();
     for (const flowInput of flows){

package/main/rules/MissingMetadataDescription.d.ts

@@ -0,0 +1,7 @@
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+import * as core from "../internals/internals";
+import { RuleCommon } from "../models/RuleCommon";
+export declare class MissingMetadataDescription extends RuleCommon implements IRuleDefinition {
+    constructor();
+    protected check(flow: core.Flow, _options: object | undefined, _suppression: Set<string>): core.Violation[];
+}

package/main/rules/MissingMetadataDescription.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MissingMetadataDescription", {
+    enumerable: true,
+    get: function() {
+        return MissingMetadataDescription;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _RuleCommon = require("../models/RuleCommon");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let MissingMetadataDescription = class MissingMetadataDescription extends _RuleCommon.RuleCommon {
+    check(flow, _options, _suppression) {
+        const violations = [];
+        flow.elements.filter((elem)=>{
+            if (elem.metaType !== "metadata" && !elem.element["description"] && elem.subtype !== "start") {
+                return elem;
+            }
+        }).forEach((elem)=>{
+            return violations.push(new _internals.Violation(elem));
+        });
+        return violations;
+    }
+    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/store/DefaultRuleStore.js

@@ -39,6 +39,7 @@ const _TriggerOrder = require("../rules/TriggerOrder");
 const _UnconnectedElement = require("../rules/UnconnectedElement");
 const _UnsafeRunningContext = require("../rules/UnsafeRunningContext");
 const _UnusedVariable = require("../rules/UnusedVariable");
+const _MissingMetadataDescription = require("../rules/MissingMetadataDescription");
 const DefaultRuleStore = {
     ActionCallsInLoop: _ActionCallsInLoop.ActionCallsInLoop,
     APIVersion: _APIVersion.APIVersion,
@@ -64,4 +65,6 @@ const DefaultRuleStore = {
     UnsafeRunningContext: _UnsafeRunningContext.UnsafeRunningContext,
     UnusedVariable: _UnusedVariable.UnusedVariable
 };
-const BetaRuleStore = {};
+const BetaRuleStore = {
+    MissingMetadataDescription: _MissingMetadataDescription.MissingMetadataDescription
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flow-scanner/lightning-flow-scanner-core",
   "description": "A lightweight engine for Flow metadata in Node.js, and browser environments. Assess and enhance Salesforce Flow automations for best practices, security, governor limits, and performance issues.",
-  "version": "6.5.0",
+  "version": "6.6.0",
   "main": "index.js",
   "types": "index.d.ts",
   "engines": {