@sfdxy/mule-lint 1.4.0

package/dist/src/rules/index.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_RULES = exports.LargeChoiceBlockRule = exports.AsyncErrorHandlerRule = exports.ScatterGatherRoutesRule = exports.MissingDocNameRule = exports.FlowDescriptionRule = exports.HttpTimeoutRule = exports.HttpContentTypeRule = exports.HttpUserAgentRule = exports.DeprecatedComponentRule = exports.DwlStandardsRule = exports.ChoiceAntiPatternRule = exports.LoggerInUntilSuccessfulRule = exports.LoggerPayloadRule = exports.LoggerCategoryRule = exports.InsecureTlsRule = exports.HardcodedCredentialsRule = exports.HardcodedHttpRule = exports.VariableNamingRule = exports.FlowCasingRule = exports.FlowNamingRule = exports.GenericErrorRule = exports.CorrelationIdRule = exports.HttpStatusRule = exports.MissingErrorHandlerRule = exports.GlobalErrorHandlerRule = void 0;
+exports.getRulesByCategory = getRulesByCategory;
+exports.getRuleById = getRuleById;
+exports.getAllRuleIds = getAllRuleIds;
+// Export base rule
+__exportStar(require("./base/BaseRule"), exports);
+// Import all rules - Error Handling
+const GlobalErrorHandlerRule_1 = require("./error-handling/GlobalErrorHandlerRule");
+const MissingErrorHandlerRule_1 = require("./error-handling/MissingErrorHandlerRule");
+const HttpStatusRule_1 = require("./error-handling/HttpStatusRule");
+const CorrelationIdRule_1 = require("./error-handling/CorrelationIdRule");
+const GenericErrorRule_1 = require("./error-handling/GenericErrorRule");
+// Import all rules - Naming
+const FlowNamingRule_1 = require("./naming/FlowNamingRule");
+const FlowCasingRule_1 = require("./naming/FlowCasingRule");
+const VariableNamingRule_1 = require("./naming/VariableNamingRule");
+// Import all rules - Security
+const HardcodedHttpRule_1 = require("./security/HardcodedHttpRule");
+const HardcodedCredentialsRule_1 = require("./security/HardcodedCredentialsRule");
+const InsecureTlsRule_1 = require("./security/InsecureTlsRule");
+// Import all rules - Logging
+const LoggerCategoryRule_1 = require("./logging/LoggerCategoryRule");
+const LoggerPayloadRule_1 = require("./logging/LoggerPayloadRule");
+const LoggerInUntilSuccessfulRule_1 = require("./logging/LoggerInUntilSuccessfulRule");
+// Import all rules - Standards
+const ChoiceAntiPatternRule_1 = require("./standards/ChoiceAntiPatternRule");
+const DwlStandardsRule_1 = require("./standards/DwlStandardsRule");
+const DeprecatedComponentRule_1 = require("./standards/DeprecatedComponentRule");
+// Import all rules - HTTP
+const HttpUserAgentRule_1 = require("./http/HttpUserAgentRule");
+const HttpContentTypeRule_1 = require("./http/HttpContentTypeRule");
+const HttpTimeoutRule_1 = require("./http/HttpTimeoutRule");
+// Import all rules - Documentation
+const FlowDescriptionRule_1 = require("./documentation/FlowDescriptionRule");
+const MissingDocNameRule_1 = require("./documentation/MissingDocNameRule");
+// Import all rules - Performance
+const ScatterGatherRoutesRule_1 = require("./performance/ScatterGatherRoutesRule");
+const AsyncErrorHandlerRule_1 = require("./performance/AsyncErrorHandlerRule");
+const LargeChoiceBlockRule_1 = require("./performance/LargeChoiceBlockRule");
+// Import all rules - Complexity
+const FlowComplexityRule_1 = require("./complexity/FlowComplexityRule");
+// Import all rules - YAML
+const YamlRules_1 = require("./yaml/YamlRules");
+// Import all rules - Structure
+const StructureRules_1 = require("./structure/StructureRules");
+// Import all rules - DataWeave
+const DataWeaveRules_1 = require("./dataweave/DataWeaveRules");
+// Import all rules - API-Led
+const ApiLedRules_1 = require("./api-led/ApiLedRules");
+// Import all rules - Experimental
+const ExperimentalRules_1 = require("./experimental/ExperimentalRules");
+// Export individual rules - Error Handling
+var GlobalErrorHandlerRule_2 = require("./error-handling/GlobalErrorHandlerRule");
+Object.defineProperty(exports, "GlobalErrorHandlerRule", { enumerable: true, get: function () { return GlobalErrorHandlerRule_2.GlobalErrorHandlerRule; } });
+var MissingErrorHandlerRule_2 = require("./error-handling/MissingErrorHandlerRule");
+Object.defineProperty(exports, "MissingErrorHandlerRule", { enumerable: true, get: function () { return MissingErrorHandlerRule_2.MissingErrorHandlerRule; } });
+var HttpStatusRule_2 = require("./error-handling/HttpStatusRule");
+Object.defineProperty(exports, "HttpStatusRule", { enumerable: true, get: function () { return HttpStatusRule_2.HttpStatusRule; } });
+var CorrelationIdRule_2 = require("./error-handling/CorrelationIdRule");
+Object.defineProperty(exports, "CorrelationIdRule", { enumerable: true, get: function () { return CorrelationIdRule_2.CorrelationIdRule; } });
+var GenericErrorRule_2 = require("./error-handling/GenericErrorRule");
+Object.defineProperty(exports, "GenericErrorRule", { enumerable: true, get: function () { return GenericErrorRule_2.GenericErrorRule; } });
+// Export individual rules - Naming
+var FlowNamingRule_2 = require("./naming/FlowNamingRule");
+Object.defineProperty(exports, "FlowNamingRule", { enumerable: true, get: function () { return FlowNamingRule_2.FlowNamingRule; } });
+var FlowCasingRule_2 = require("./naming/FlowCasingRule");
+Object.defineProperty(exports, "FlowCasingRule", { enumerable: true, get: function () { return FlowCasingRule_2.FlowCasingRule; } });
+var VariableNamingRule_2 = require("./naming/VariableNamingRule");
+Object.defineProperty(exports, "VariableNamingRule", { enumerable: true, get: function () { return VariableNamingRule_2.VariableNamingRule; } });
+// Export individual rules - Security
+var HardcodedHttpRule_2 = require("./security/HardcodedHttpRule");
+Object.defineProperty(exports, "HardcodedHttpRule", { enumerable: true, get: function () { return HardcodedHttpRule_2.HardcodedHttpRule; } });
+var HardcodedCredentialsRule_2 = require("./security/HardcodedCredentialsRule");
+Object.defineProperty(exports, "HardcodedCredentialsRule", { enumerable: true, get: function () { return HardcodedCredentialsRule_2.HardcodedCredentialsRule; } });
+var InsecureTlsRule_2 = require("./security/InsecureTlsRule");
+Object.defineProperty(exports, "InsecureTlsRule", { enumerable: true, get: function () { return InsecureTlsRule_2.InsecureTlsRule; } });
+// Export individual rules - Logging
+var LoggerCategoryRule_2 = require("./logging/LoggerCategoryRule");
+Object.defineProperty(exports, "LoggerCategoryRule", { enumerable: true, get: function () { return LoggerCategoryRule_2.LoggerCategoryRule; } });
+var LoggerPayloadRule_2 = require("./logging/LoggerPayloadRule");
+Object.defineProperty(exports, "LoggerPayloadRule", { enumerable: true, get: function () { return LoggerPayloadRule_2.LoggerPayloadRule; } });
+var LoggerInUntilSuccessfulRule_2 = require("./logging/LoggerInUntilSuccessfulRule");
+Object.defineProperty(exports, "LoggerInUntilSuccessfulRule", { enumerable: true, get: function () { return LoggerInUntilSuccessfulRule_2.LoggerInUntilSuccessfulRule; } });
+// Export individual rules - Standards
+var ChoiceAntiPatternRule_2 = require("./standards/ChoiceAntiPatternRule");
+Object.defineProperty(exports, "ChoiceAntiPatternRule", { enumerable: true, get: function () { return ChoiceAntiPatternRule_2.ChoiceAntiPatternRule; } });
+var DwlStandardsRule_2 = require("./standards/DwlStandardsRule");
+Object.defineProperty(exports, "DwlStandardsRule", { enumerable: true, get: function () { return DwlStandardsRule_2.DwlStandardsRule; } });
+var DeprecatedComponentRule_2 = require("./standards/DeprecatedComponentRule");
+Object.defineProperty(exports, "DeprecatedComponentRule", { enumerable: true, get: function () { return DeprecatedComponentRule_2.DeprecatedComponentRule; } });
+// Export individual rules - HTTP
+var HttpUserAgentRule_2 = require("./http/HttpUserAgentRule");
+Object.defineProperty(exports, "HttpUserAgentRule", { enumerable: true, get: function () { return HttpUserAgentRule_2.HttpUserAgentRule; } });
+var HttpContentTypeRule_2 = require("./http/HttpContentTypeRule");
+Object.defineProperty(exports, "HttpContentTypeRule", { enumerable: true, get: function () { return HttpContentTypeRule_2.HttpContentTypeRule; } });
+var HttpTimeoutRule_2 = require("./http/HttpTimeoutRule");
+Object.defineProperty(exports, "HttpTimeoutRule", { enumerable: true, get: function () { return HttpTimeoutRule_2.HttpTimeoutRule; } });
+// Export individual rules - Documentation
+var FlowDescriptionRule_2 = require("./documentation/FlowDescriptionRule");
+Object.defineProperty(exports, "FlowDescriptionRule", { enumerable: true, get: function () { return FlowDescriptionRule_2.FlowDescriptionRule; } });
+var MissingDocNameRule_2 = require("./documentation/MissingDocNameRule");
+Object.defineProperty(exports, "MissingDocNameRule", { enumerable: true, get: function () { return MissingDocNameRule_2.MissingDocNameRule; } });
+// Export individual rules - Performance
+var ScatterGatherRoutesRule_2 = require("./performance/ScatterGatherRoutesRule");
+Object.defineProperty(exports, "ScatterGatherRoutesRule", { enumerable: true, get: function () { return ScatterGatherRoutesRule_2.ScatterGatherRoutesRule; } });
+var AsyncErrorHandlerRule_2 = require("./performance/AsyncErrorHandlerRule");
+Object.defineProperty(exports, "AsyncErrorHandlerRule", { enumerable: true, get: function () { return AsyncErrorHandlerRule_2.AsyncErrorHandlerRule; } });
+var LargeChoiceBlockRule_2 = require("./performance/LargeChoiceBlockRule");
+Object.defineProperty(exports, "LargeChoiceBlockRule", { enumerable: true, get: function () { return LargeChoiceBlockRule_2.LargeChoiceBlockRule; } });
+/**
+ * All available rules - instantiated and ready to use
+ * Total: 25 rules
+ */
+exports.ALL_RULES = [
+    // Error Handling Rules (MULE-001, 003, 005, 007, 009)
+    new GlobalErrorHandlerRule_1.GlobalErrorHandlerRule(),
+    new MissingErrorHandlerRule_1.MissingErrorHandlerRule(),
+    new HttpStatusRule_1.HttpStatusRule(),
+    new CorrelationIdRule_1.CorrelationIdRule(),
+    new GenericErrorRule_1.GenericErrorRule(),
+    // Naming Rules (MULE-002, 101, 102)
+    new FlowNamingRule_1.FlowNamingRule(),
+    new FlowCasingRule_1.FlowCasingRule(),
+    new VariableNamingRule_1.VariableNamingRule(),
+    // Security Rules (MULE-004, 201, 202)
+    new HardcodedHttpRule_1.HardcodedHttpRule(),
+    new HardcodedCredentialsRule_1.HardcodedCredentialsRule(),
+    new InsecureTlsRule_1.InsecureTlsRule(),
+    // Logging Rules (MULE-006, 301, 303)
+    new LoggerCategoryRule_1.LoggerCategoryRule(),
+    new LoggerPayloadRule_1.LoggerPayloadRule(),
+    new LoggerInUntilSuccessfulRule_1.LoggerInUntilSuccessfulRule(),
+    // Standards Rules (MULE-008, 010, 701)
+    new ChoiceAntiPatternRule_1.ChoiceAntiPatternRule(),
+    new DwlStandardsRule_1.DwlStandardsRule(),
+    new DeprecatedComponentRule_1.DeprecatedComponentRule(),
+    // HTTP Rules (MULE-401, 402, 403)
+    new HttpUserAgentRule_1.HttpUserAgentRule(),
+    new HttpContentTypeRule_1.HttpContentTypeRule(),
+    new HttpTimeoutRule_1.HttpTimeoutRule(),
+    // Documentation Rules (MULE-601, 604)
+    new FlowDescriptionRule_1.FlowDescriptionRule(),
+    new MissingDocNameRule_1.MissingDocNameRule(),
+    // Performance Rules (MULE-501, 502, 503)
+    new ScatterGatherRoutesRule_1.ScatterGatherRoutesRule(),
+    new AsyncErrorHandlerRule_1.AsyncErrorHandlerRule(),
+    new LargeChoiceBlockRule_1.LargeChoiceBlockRule(),
+    // Complexity Rules (MULE-801)
+    new FlowComplexityRule_1.FlowComplexityRule(),
+    // YAML Rules (YAML-001, 003, 004)
+    new YamlRules_1.EnvironmentFilesRule(),
+    new YamlRules_1.PropertyNamingRule(),
+    new YamlRules_1.PlaintextSecretsRule(),
+    // Structure Rules (MULE-802, 803, 804)
+    new StructureRules_1.ProjectStructureRule(),
+    new StructureRules_1.GlobalConfigRule(),
+    new StructureRules_1.MonolithicXmlRule(),
+    // DataWeave Rules (DW-001, 002, 003)
+    new DataWeaveRules_1.ExternalDwlRule(),
+    new DataWeaveRules_1.DwlNamingRule(),
+    new DataWeaveRules_1.DwlModulesRule(),
+    // API-Led Rules (API-001, 002, 003)
+    new ApiLedRules_1.ExperienceLayerRule(),
+    new ApiLedRules_1.ProcessLayerRule(),
+    new ApiLedRules_1.SystemLayerRule(),
+    // Experimental Rules (EXP-001, 002, 003)
+    new ExperimentalRules_1.FlowRefDepthRule(),
+    new ExperimentalRules_1.ConnectorConfigNamingRule(),
+    new ExperimentalRules_1.MUnitCoverageRule(),
+];
+/**
+ * Get rules by category
+ */
+function getRulesByCategory(category) {
+    return exports.ALL_RULES.filter(rule => rule.category === category);
+}
+/**
+ * Get rule by ID
+ */
+function getRuleById(id) {
+    return exports.ALL_RULES.find(rule => rule.id === id);
+}
+/**
+ * Get all rule IDs
+ */
+function getAllRuleIds() {
+    return exports.ALL_RULES.map(rule => rule.id);
+}
+//# sourceMappingURL=index.js.map

package/dist/src/rules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/rules/index.ts"],"names":[],"mappings":"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"}

package/dist/src/rules/logging/LoggerCategoryRule.d.ts

@@ -0,0 +1,21 @@
+import { ValidationContext, Issue } from '../../types';
+import { BaseRule } from '../base/BaseRule';
+/**
+ * MULE-006: Logger Category Required
+ *
+ * All loggers must have a category attribute for proper log filtering.
+ * Without categories, logs are harder to filter and analyze.
+ */
+export declare class LoggerCategoryRule extends BaseRule {
+    id: string;
+    name: string;
+    description: string;
+    severity: "warning";
+    category: "logging";
+    validate(doc: Document, context: ValidationContext): Issue[];
+    /**
+     * Suggest a category based on file path
+     */
+    private suggestCategory;
+}
+//# sourceMappingURL=LoggerCategoryRule.d.ts.map

package/dist/src/rules/logging/LoggerCategoryRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerCategoryRule.d.ts","sourceRoot":"","sources":["../../../../src/rules/logging/LoggerCategoryRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,QAAQ;IAC5C,EAAE,SAAc;IAChB,IAAI,SAA8B;IAClC,WAAW,SAA2E;IACtF,QAAQ,EAAG,SAAS,CAAU;IAC9B,QAAQ,EAAG,SAAS,CAAU;IAE9B,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,KAAK,EAAE;IA8C5D;;OAEG;IACH,OAAO,CAAC,eAAe;CAW1B"}

package/dist/src/rules/logging/LoggerCategoryRule.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerCategoryRule = void 0;
+const BaseRule_1 = require("../base/BaseRule");
+/**
+ * MULE-006: Logger Category Required
+ *
+ * All loggers must have a category attribute for proper log filtering.
+ * Without categories, logs are harder to filter and analyze.
+ */
+class LoggerCategoryRule extends BaseRule_1.BaseRule {
+    id = 'MULE-006';
+    name = 'Logger Category Required';
+    description = 'All loggers should have a category attribute for proper log filtering';
+    severity = 'warning';
+    category = 'logging';
+    validate(doc, context) {
+        const issues = [];
+        // Get optional required prefix
+        const requiredPrefix = this.getOption(context, 'requiredPrefix', null);
+        // Find loggers without category
+        const loggersWithoutCategory = this.select('//mule:logger[not(@category)]', doc);
+        for (const logger of loggersWithoutCategory) {
+            const docName = this.getDocName(logger) ?? 'Logger';
+            const suggestedCategory = this.suggestCategory(context.relativePath);
+            issues.push(this.createIssue(logger, `Logger "${docName}" is missing 'category' attribute`, {
+                suggestion: `Add category="${suggestedCategory}"`
+            }));
+        }
+        // If required prefix is set, verify all loggers use it
+        if (requiredPrefix) {
+            const loggersWithCategory = this.select('//mule:logger[@category]', doc);
+            for (const logger of loggersWithCategory) {
+                const category = this.getAttribute(logger, 'category');
+                if (category && !category.startsWith(requiredPrefix)) {
+                    const docName = this.getDocName(logger) ?? 'Logger';
+                    issues.push(this.createIssue(logger, `Logger "${docName}" category "${category}" should start with "${requiredPrefix}"`, {
+                        suggestion: `Update category to "${requiredPrefix}.${category}"`,
+                        severity: 'info'
+                    }));
+                }
+            }
+        }
+        return issues;
+    }
+    /**
+     * Suggest a category based on file path
+     */
+    suggestCategory(relativePath) {
+        // Convert file path to a category
+        // e.g., src/main/mule/impl/orders-impl.xml -> com.myorg.impl.orders
+        const baseName = relativePath
+            .replace(/^src\/main\/mule\//, '')
+            .replace(/\.xml$/, '')
+            .replace(/[/\\]/g, '.')
+            .replace(/-/g, '.');
+        return `com.myorg.${baseName}`;
+    }
+}
+exports.LoggerCategoryRule = LoggerCategoryRule;
+//# sourceMappingURL=LoggerCategoryRule.js.map

package/dist/src/rules/logging/LoggerCategoryRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerCategoryRule.js","sourceRoot":"","sources":["../../../../src/rules/logging/LoggerCategoryRule.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAE5C;;;;;GAKG;AACH,MAAa,kBAAmB,SAAQ,mBAAQ;IAC5C,EAAE,GAAG,UAAU,CAAC;IAChB,IAAI,GAAG,0BAA0B,CAAC;IAClC,WAAW,GAAG,uEAAuE,CAAC;IACtF,QAAQ,GAAG,SAAkB,CAAC;IAC9B,QAAQ,GAAG,SAAkB,CAAC;IAE9B,QAAQ,CAAC,GAAa,EAAE,OAA0B;QAC9C,MAAM,MAAM,GAAY,EAAE,CAAC;QAE3B,+BAA+B;QAC/B,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAgB,OAAO,EAAE,gBAAgB,EAAE,IAAI,CAAC,CAAC;QAEtF,gCAAgC;QAChC,MAAM,sBAAsB,GAAG,IAAI,CAAC,MAAM,CAAC,+BAA+B,EAAE,GAAG,CAAC,CAAC;QAEjF,KAAK,MAAM,MAAM,IAAI,sBAAsB,EAAE,CAAC;YAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC;YACpD,MAAM,iBAAiB,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAErE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CACxB,MAAM,EACN,WAAW,OAAO,mCAAmC,EACrD;gBACI,UAAU,EAAE,iBAAiB,iBAAiB,GAAG;aACpD,CACJ,CAAC,CAAC;QACP,CAAC;QAED,uDAAuD;QACvD,IAAI,cAAc,EAAE,CAAC;YACjB,MAAM,mBAAmB,GAAG,IAAI,CAAC,MAAM,CAAC,0BAA0B,EAAE,GAAG,CAAC,CAAC;YAEzE,KAAK,MAAM,MAAM,IAAI,mBAAmB,EAAE,CAAC;gBACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;gBACvD,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;oBACnD,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC;oBAEpD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CACxB,MAAM,EACN,WAAW,OAAO,eAAe,QAAQ,wBAAwB,cAAc,GAAG,EAClF;wBACI,UAAU,EAAE,uBAAuB,cAAc,IAAI,QAAQ,GAAG;wBAChE,QAAQ,EAAE,MAAM;qBACnB,CACJ,CAAC,CAAC;gBACP,CAAC;YACL,CAAC;QACL,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;OAEG;IACK,eAAe,CAAC,YAAoB;QACxC,kCAAkC;QAClC,oEAAoE;QACpE,MAAM,QAAQ,GAAG,YAAY;aACxB,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC;aACjC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC;aACrB,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC;aACtB,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAExB,OAAO,aAAa,QAAQ,EAAE,CAAC;IACnC,CAAC;CACJ;AAnED,gDAmEC"}

package/dist/src/rules/logging/LoggerInUntilSuccessfulRule.d.ts

@@ -0,0 +1,16 @@
+import { ValidationContext, Issue } from '../../types';
+import { BaseRule } from '../base/BaseRule';
+/**
+ * MULE-303: Logger in Until-Successful
+ *
+ * Avoid loggers inside until-successful scope (floods logs on retries).
+ */
+export declare class LoggerInUntilSuccessfulRule extends BaseRule {
+    id: string;
+    name: string;
+    description: string;
+    severity: "warning";
+    category: "logging";
+    validate(doc: Document, _context: ValidationContext): Issue[];
+}
+//# sourceMappingURL=LoggerInUntilSuccessfulRule.d.ts.map

package/dist/src/rules/logging/LoggerInUntilSuccessfulRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerInUntilSuccessfulRule.d.ts","sourceRoot":"","sources":["../../../../src/rules/logging/LoggerInUntilSuccessfulRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,2BAA4B,SAAQ,QAAQ;IACrD,EAAE,SAAc;IAChB,IAAI,SAAgC;IACpC,WAAW,SAAiD;IAC5D,QAAQ,EAAG,SAAS,CAAU;IAC9B,QAAQ,EAAG,SAAS,CAAU;IAE9B,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,iBAAiB,GAAG,KAAK,EAAE;CAqBhE"}

package/dist/src/rules/logging/LoggerInUntilSuccessfulRule.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerInUntilSuccessfulRule = void 0;
+const BaseRule_1 = require("../base/BaseRule");
+/**
+ * MULE-303: Logger in Until-Successful
+ *
+ * Avoid loggers inside until-successful scope (floods logs on retries).
+ */
+class LoggerInUntilSuccessfulRule extends BaseRule_1.BaseRule {
+    id = 'MULE-303';
+    name = 'Logger in Until-Successful';
+    description = 'Avoid loggers inside until-successful scope';
+    severity = 'warning';
+    category = 'logging';
+    validate(doc, _context) {
+        const issues = [];
+        const loggersInUntilSuccessful = this.select('//mule:until-successful//mule:logger', doc);
+        for (const logger of loggersInUntilSuccessful) {
+            const docName = this.getDocName(logger) ?? 'Logger';
+            issues.push(this.createIssue(logger, `Logger "${docName}" inside until-successful may flood logs on retries`, {
+                suggestion: 'Move logger outside until-successful or use conditional logging'
+            }));
+        }
+        return issues;
+    }
+}
+exports.LoggerInUntilSuccessfulRule = LoggerInUntilSuccessfulRule;
+//# sourceMappingURL=LoggerInUntilSuccessfulRule.js.map

package/dist/src/rules/logging/LoggerInUntilSuccessfulRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerInUntilSuccessfulRule.js","sourceRoot":"","sources":["../../../../src/rules/logging/LoggerInUntilSuccessfulRule.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAE5C;;;;GAIG;AACH,MAAa,2BAA4B,SAAQ,mBAAQ;IACrD,EAAE,GAAG,UAAU,CAAC;IAChB,IAAI,GAAG,4BAA4B,CAAC;IACpC,WAAW,GAAG,6CAA6C,CAAC;IAC5D,QAAQ,GAAG,SAAkB,CAAC;IAC9B,QAAQ,GAAG,SAAkB,CAAC;IAE9B,QAAQ,CAAC,GAAa,EAAE,QAA2B;QAC/C,MAAM,MAAM,GAAY,EAAE,CAAC;QAE3B,MAAM,wBAAwB,GAAG,IAAI,CAAC,MAAM,CACxC,sCAAsC,EACtC,GAAG,CACN,CAAC;QAEF,KAAK,MAAM,MAAM,IAAI,wBAAwB,EAAE,CAAC;YAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC;YACpD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CACxB,MAAM,EACN,WAAW,OAAO,qDAAqD,EACvE;gBACI,UAAU,EAAE,iEAAiE;aAChF,CACJ,CAAC,CAAC;QACP,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AA5BD,kEA4BC"}

package/dist/src/rules/logging/LoggerPayloadRule.d.ts

@@ -0,0 +1,17 @@
+import { ValidationContext, Issue } from '../../types';
+import { BaseRule } from '../base/BaseRule';
+/**
+ * MULE-301: Logger Payload Reference
+ *
+ * Loggers should not directly reference #[payload] for security/performance.
+ */
+export declare class LoggerPayloadRule extends BaseRule {
+    id: string;
+    name: string;
+    description: string;
+    severity: "warning";
+    category: "logging";
+    validate(doc: Document, _context: ValidationContext): Issue[];
+    private hasDirectPayloadReference;
+}
+//# sourceMappingURL=LoggerPayloadRule.d.ts.map

package/dist/src/rules/logging/LoggerPayloadRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerPayloadRule.d.ts","sourceRoot":"","sources":["../../../../src/rules/logging/LoggerPayloadRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,QAAQ;IAC3C,EAAE,SAAc;IAChB,IAAI,SAA8B;IAClC,WAAW,SAAoD;IAC/D,QAAQ,EAAG,SAAS,CAAU;IAC9B,QAAQ,EAAG,SAAS,CAAU;IAE9B,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,iBAAiB,GAAG,KAAK,EAAE;IAwB7D,OAAO,CAAC,yBAAyB;CAMpC"}

package/dist/src/rules/logging/LoggerPayloadRule.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerPayloadRule = void 0;
+const BaseRule_1 = require("../base/BaseRule");
+/**
+ * MULE-301: Logger Payload Reference
+ *
+ * Loggers should not directly reference #[payload] for security/performance.
+ */
+class LoggerPayloadRule extends BaseRule_1.BaseRule {
+    id = 'MULE-301';
+    name = 'Logger Payload Reference';
+    description = 'Loggers should not directly log entire payload';
+    severity = 'warning';
+    category = 'logging';
+    validate(doc, _context) {
+        const issues = [];
+        const loggers = this.select('//mule:logger[@message]', doc);
+        for (const logger of loggers) {
+            const message = this.getAttribute(logger, 'message') ?? '';
+            // Check for direct payload logging
+            if (this.hasDirectPayloadReference(message)) {
+                const docName = this.getDocName(logger) ?? 'Logger';
+                issues.push(this.createIssue(logger, `Logger "${docName}" logs entire payload - security/performance risk`, {
+                    suggestion: 'Log specific fields instead: #[payload.orderId]'
+                }));
+            }
+        }
+        return issues;
+    }
+    hasDirectPayloadReference(message) {
+        // Match #[payload] but not #[payload.something]
+        return /\#\[payload\s*\]/.test(message) ||
+            /\#\[\s*payload\s*\]/.test(message) ||
+            message === '#[payload]';
+    }
+}
+exports.LoggerPayloadRule = LoggerPayloadRule;
+//# sourceMappingURL=LoggerPayloadRule.js.map

package/dist/src/rules/logging/LoggerPayloadRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerPayloadRule.js","sourceRoot":"","sources":["../../../../src/rules/logging/LoggerPayloadRule.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAE5C;;;;GAIG;AACH,MAAa,iBAAkB,SAAQ,mBAAQ;IAC3C,EAAE,GAAG,UAAU,CAAC;IAChB,IAAI,GAAG,0BAA0B,CAAC;IAClC,WAAW,GAAG,gDAAgD,CAAC;IAC/D,QAAQ,GAAG,SAAkB,CAAC;IAC9B,QAAQ,GAAG,SAAkB,CAAC;IAE9B,QAAQ,CAAC,GAAa,EAAE,QAA2B;QAC/C,MAAM,MAAM,GAAY,EAAE,CAAC;QAE3B,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,yBAAyB,EAAE,GAAG,CAAC,CAAC;QAE5D,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC;YAE3D,mCAAmC;YACnC,IAAI,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC;gBACpD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CACxB,MAAM,EACN,WAAW,OAAO,mDAAmD,EACrE;oBACI,UAAU,EAAE,iDAAiD;iBAChE,CACJ,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAEO,yBAAyB,CAAC,OAAe;QAC7C,gDAAgD;QAChD,OAAO,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC;YACnC,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC;YACnC,OAAO,KAAK,YAAY,CAAC;IACjC,CAAC;CACJ;AArCD,8CAqCC"}

package/dist/src/rules/naming/FlowCasingRule.d.ts

@@ -0,0 +1,18 @@
+import { ValidationContext, Issue } from '../../types';
+import { BaseRule } from '../base/BaseRule';
+/**
+ * MULE-101: Flow Name Casing
+ *
+ * Flow names should follow consistent casing (kebab-case recommended).
+ */
+export declare class FlowCasingRule extends BaseRule {
+    id: string;
+    name: string;
+    description: string;
+    severity: "warning";
+    category: "naming";
+    private readonly KEBAB_CASE_PATTERN;
+    validate(doc: Document, _context: ValidationContext): Issue[];
+    private toKebabCase;
+}
+//# sourceMappingURL=FlowCasingRule.d.ts.map

package/dist/src/rules/naming/FlowCasingRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowCasingRule.d.ts","sourceRoot":"","sources":["../../../../src/rules/naming/FlowCasingRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,QAAQ;IACxC,EAAE,SAAc;IAChB,IAAI,SAAsB;IAC1B,WAAW,SAAoD;IAC/D,QAAQ,EAAG,SAAS,CAAU;IAC9B,QAAQ,EAAG,QAAQ,CAAU;IAE7B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAoD;IAEvF,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,iBAAiB,GAAG,KAAK,EAAE;IAuB7D,OAAO,CAAC,WAAW;CAMtB"}

package/dist/src/rules/naming/FlowCasingRule.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowCasingRule = void 0;
+const BaseRule_1 = require("../base/BaseRule");
+/**
+ * MULE-101: Flow Name Casing
+ *
+ * Flow names should follow consistent casing (kebab-case recommended).
+ */
+class FlowCasingRule extends BaseRule_1.BaseRule {
+    id = 'MULE-101';
+    name = 'Flow Name Casing';
+    description = 'Flow names should follow kebab-case convention';
+    severity = 'warning';
+    category = 'naming';
+    KEBAB_CASE_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*(-flow|-subflow)?$/;
+    validate(doc, _context) {
+        const issues = [];
+        const flows = this.select('//mule:flow | //mule:sub-flow', doc);
+        for (const flow of flows) {
+            const name = this.getNameAttribute(flow);
+            if (!name)
+                continue;
+            if (!this.KEBAB_CASE_PATTERN.test(name)) {
+                issues.push(this.createIssue(flow, `Flow name "${name}" should be kebab-case`, {
+                    suggestion: `Rename to "${this.toKebabCase(name)}"`
+                }));
+            }
+        }
+        return issues;
+    }
+    toKebabCase(name) {
+        return name
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    }
+}
+exports.FlowCasingRule = FlowCasingRule;
+//# sourceMappingURL=FlowCasingRule.js.map

package/dist/src/rules/naming/FlowCasingRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowCasingRule.js","sourceRoot":"","sources":["../../../../src/rules/naming/FlowCasingRule.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAE5C;;;;GAIG;AACH,MAAa,cAAe,SAAQ,mBAAQ;IACxC,EAAE,GAAG,UAAU,CAAC;IAChB,IAAI,GAAG,kBAAkB,CAAC;IAC1B,WAAW,GAAG,gDAAgD,CAAC;IAC/D,QAAQ,GAAG,SAAkB,CAAC;IAC9B,QAAQ,GAAG,QAAiB,CAAC;IAEZ,kBAAkB,GAAG,gDAAgD,CAAC;IAEvF,QAAQ,CAAC,GAAa,EAAE,QAA2B;QAC/C,MAAM,MAAM,GAAY,EAAE,CAAC;QAE3B,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,+BAA+B,EAAE,GAAG,CAAC,CAAC;QAEhE,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACvB,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YACzC,IAAI,CAAC,IAAI;gBAAE,SAAS;YAEpB,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBACtC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CACxB,IAAI,EACJ,cAAc,IAAI,wBAAwB,EAC1C;oBACI,UAAU,EAAE,cAAc,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG;iBACtD,CACJ,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;IAEO,WAAW,CAAC,IAAY;QAC5B,OAAO,IAAI;aACN,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC;aACnC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC;aACvB,WAAW,EAAE,CAAC;IACvB,CAAC;CACJ;AAtCD,wCAsCC"}

package/dist/src/rules/naming/FlowNamingRule.d.ts

@@ -0,0 +1,17 @@
+import { ValidationContext, Issue } from '../../types';
+import { BaseRule } from '../base/BaseRule';
+/**
+ * MULE-002: Flow Naming Convention
+ *
+ * Flows must end with "-flow" suffix, sub-flows with "-subflow".
+ * This ensures consistent naming across the project.
+ */
+export declare class FlowNamingRule extends BaseRule {
+    id: string;
+    name: string;
+    description: string;
+    severity: "warning";
+    category: "naming";
+    validate(doc: Document, context: ValidationContext): Issue[];
+}
+//# sourceMappingURL=FlowNamingRule.d.ts.map

package/dist/src/rules/naming/FlowNamingRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowNamingRule.d.ts","sourceRoot":"","sources":["../../../../src/rules/naming/FlowNamingRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,QAAQ;IACxC,EAAE,SAAc;IAChB,IAAI,SAA4B;IAChC,WAAW,SAAoF;IAC/F,QAAQ,EAAG,SAAS,CAAU;IAC9B,QAAQ,EAAG,QAAQ,CAAU;IAE7B,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,GAAG,KAAK,EAAE;CAyD/D"}

package/dist/src/rules/naming/FlowNamingRule.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowNamingRule = void 0;
+const BaseRule_1 = require("../base/BaseRule");
+/**
+ * MULE-002: Flow Naming Convention
+ *
+ * Flows must end with "-flow" suffix, sub-flows with "-subflow".
+ * This ensures consistent naming across the project.
+ */
+class FlowNamingRule extends BaseRule_1.BaseRule {
+    id = 'MULE-002';
+    name = 'Flow Naming Convention';
+    description = 'Flows should end with "-flow", sub-flows with "-subflow" for consistent naming';
+    severity = 'warning';
+    category = 'naming';
+    validate(doc, context) {
+        const issues = [];
+        // Get configurable suffixes
+        const flowSuffix = this.getOption(context, 'flowSuffix', '-flow');
+        const subflowSuffix = this.getOption(context, 'subflowSuffix', '-subflow');
+        const excludePatterns = this.getOption(context, 'excludePatterns', [
+            '*-api-main',
+            '*-api-console',
+        ]);
+        // Check flows
+        const flows = this.select('//mule:flow', doc);
+        for (const flow of flows) {
+            const name = this.getNameAttribute(flow);
+            if (!name) {
+                continue;
+            }
+            // Skip excluded patterns
+            if (this.isExcluded(name, excludePatterns)) {
+                continue;
+            }
+            if (!name.endsWith(flowSuffix)) {
+                issues.push(this.createIssue(flow, `Flow "${name}" should end with "${flowSuffix}"`, { suggestion: `Rename to "${name}${flowSuffix}"` }));
+            }
+        }
+        // Check sub-flows
+        const subflows = this.select('//mule:sub-flow', doc);
+        for (const subflow of subflows) {
+            const name = this.getNameAttribute(subflow);
+            if (!name) {
+                continue;
+            }
+            // Skip excluded patterns
+            if (this.isExcluded(name, excludePatterns)) {
+                continue;
+            }
+            if (!name.endsWith(subflowSuffix)) {
+                issues.push(this.createIssue(subflow, `Sub-flow "${name}" should end with "${subflowSuffix}"`, { suggestion: `Rename to "${name}${subflowSuffix}"` }));
+            }
+        }
+        return issues;
+    }
+}
+exports.FlowNamingRule = FlowNamingRule;
+//# sourceMappingURL=FlowNamingRule.js.map

package/dist/src/rules/naming/FlowNamingRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlowNamingRule.js","sourceRoot":"","sources":["../../../../src/rules/naming/FlowNamingRule.ts"],"names":[],"mappings":";;;AACA,+CAA4C;AAE5C;;;;;GAKG;AACH,MAAa,cAAe,SAAQ,mBAAQ;IACxC,EAAE,GAAG,UAAU,CAAC;IAChB,IAAI,GAAG,wBAAwB,CAAC;IAChC,WAAW,GAAG,gFAAgF,CAAC;IAC/F,QAAQ,GAAG,SAAkB,CAAC;IAC9B,QAAQ,GAAG,QAAiB,CAAC;IAE7B,QAAQ,CAAC,GAAa,EAAE,OAA0B;QAC9C,MAAM,MAAM,GAAY,EAAE,CAAC;QAE3B,4BAA4B;QAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;QAClE,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,UAAU,CAAC,CAAC;QAC3E,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAW,OAAO,EAAE,iBAAiB,EAAE;YACzE,YAAY;YACZ,eAAe;SAClB,CAAC,CAAC;QAEH,cAAc;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;QAC9C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACvB,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YACzC,IAAI,CAAC,IAAI,EAAE,CAAC;gBACR,SAAS;YACb,CAAC;YAED,yBAAyB;YACzB,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,eAAe,CAAC,EAAE,CAAC;gBACzC,SAAS;YACb,CAAC;YAED,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC7B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CACxB,IAAI,EACJ,SAAS,IAAI,sBAAsB,UAAU,GAAG,EAChD,EAAE,UAAU,EAAE,cAAc,IAAI,GAAG,UAAU,GAAG,EAAE,CACrD,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QAED,kBAAkB;QAClB,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC;QACrD,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC7B,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;YAC5C,IAAI,CAAC,IAAI,EAAE,CAAC;gBACR,SAAS;YACb,CAAC;YAED,yBAAyB;YACzB,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,eAAe,CAAC,EAAE,CAAC;gBACzC,SAAS;YACb,CAAC;YAED,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;gBAChC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CACxB,OAAO,EACP,aAAa,IAAI,sBAAsB,aAAa,GAAG,EACvD,EAAE,UAAU,EAAE,cAAc,IAAI,GAAG,aAAa,GAAG,EAAE,CACxD,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AAhED,wCAgEC"}

package/dist/src/rules/naming/VariableNamingRule.d.ts

@@ -0,0 +1,18 @@
+import { ValidationContext, Issue } from '../../types';
+import { BaseRule } from '../base/BaseRule';
+/**
+ * MULE-102: Variable Naming Convention
+ *
+ * Variables should follow camelCase naming.
+ */
+export declare class VariableNamingRule extends BaseRule {
+    id: string;
+    name: string;
+    description: string;
+    severity: "warning";
+    category: "naming";
+    private readonly CAMEL_CASE_PATTERN;
+    validate(doc: Document, _context: ValidationContext): Issue[];
+    private toCamelCase;
+}
+//# sourceMappingURL=VariableNamingRule.d.ts.map

package/dist/src/rules/naming/VariableNamingRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariableNamingRule.d.ts","sourceRoot":"","sources":["../../../../src/rules/naming/VariableNamingRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,QAAQ;IAC5C,EAAE,SAAc;IAChB,IAAI,SAAgC;IACpC,WAAW,SAA8C;IACzD,QAAQ,EAAG,SAAS,CAAU;IAC9B,QAAQ,EAAG,QAAQ,CAAU;IAE7B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAyB;IAE5D,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,iBAAiB,GAAG,KAAK,EAAE;IAuB7D,OAAO,CAAC,WAAW;CAKtB"}