ds-sfcoe-ailabs/lib/common/utils/ruleUtils.js

AI-powered code review tool with static analysis integration for comprehensive code quality assessment.

import { REVIEW_COMMAND_HINTS_DEFAULTS, RULE_TYPE_MAP, SUGGESTED_FIXES, } from './constants.js';
/**
 * Rule type mapping utility for various linting and analysis rules
 *
 * Provides methods for extracting rule types, generating suggested fixes,
 * creating unique keys for deduplication, and categorizing rules by
 * language type (JavaScript/TypeScript vs Apex).
 *
 * @example
 * ```typescript
 * const ruleType = RuleUtils.extractRuleType('no-unused-vars');
 * const fix = RuleUtils.getSuggestedFix('no-unused-vars');
 * const isJs = RuleUtils.isJavaScriptRule('@typescript-eslint/no-unused-vars');
 * ```
 */
export class RuleUtils {
    /**
     * Extract rule type from rule ID
     *
     * @param ruleId - The rule identifier to extract type from
     * @returns The rule type category or 'General' if not found
     * @example
     * ```typescript
     * const ruleType = RuleUtils.extractRuleType('no-unused-vars');
     * console.log(ruleType); // 'JavaScript Best Practices'
     *
     * const apexType = RuleUtils.extractRuleType('ApexCRUDViolation');
     * console.log(apexType); // 'Apex Security'
     * ```
     */
    static extractRuleType(ruleId) {
        return RULE_TYPE_MAP[ruleId] || REVIEW_COMMAND_HINTS_DEFAULTS.RULE_TYPE;
    }
    /**
     * Get suggested fix for a rule ID
     *
     * @param ruleId - The rule identifier to get fix for
     * @param message - Optional rule message for context
     * @returns Suggested fix description for the rule
     * @example
     * ```typescript
     * const fix = RuleUtils.getSuggestedFix('no-unused-vars', 'Variable x is unused');
     * console.log(fix); // 'Remove unused variable or prefix with underscore'
     *
     * const genericFix = RuleUtils.getSuggestedFix('unknown-rule');
     * console.log(genericFix); // 'Review and fix unknown-rule violation'
     * ```
     */
    static getSuggestedFix(ruleId, message) {
        return (SUGGESTED_FIXES[ruleId] ||
            `Review and fix ${ruleId} violation${message !== undefined ? `: ${message}` : ''}`);
    }
    /**
     * Create a unique entry key for deduplication
     *
     * @param fileName - The file name
     * @param ruleId - The rule identifier
     * @param lineNumber - The line number where the issue occurs
     * @returns Unique key string for deduplication
     * @example
     * ```typescript
     * const key = RuleUtils.createEntryKey('file.js', 'no-unused-vars', 42);
     * console.log(key); // 'file.js-no-unused-vars-42'
     *
     * const apexKey = RuleUtils.createEntryKey('MyClass.cls', 'ApexComplexity', 15);
     * console.log(apexKey); // 'MyClass.cls-ApexComplexity-15'
     * ```
     */
    static createEntryKey(fileName, ruleId, lineNumber) {
        return `${fileName}-${ruleId}-${lineNumber}`;
    }
    /**
     * Check if a rule ID is a JavaScript/TypeScript rule
     *
     * @param ruleId - The rule identifier to check
     * @returns True if the rule is for JavaScript/TypeScript/LWC code
     * @example
     * ```typescript
     * const isJs = RuleUtils.isJavaScriptRule('@typescript-eslint/no-unused-vars');
     * console.log(isJs); // true
     *
     * const isLwc = RuleUtils.isJavaScriptRule('@lwc/no-api-reassignments');
     * console.log(isLwc); // true
     *
     * const isApex = RuleUtils.isJavaScriptRule('ApexComplexity');
     * console.log(isApex); // false
     * ```
     */
    static isJavaScriptRule(ruleId) {
        const ruleType = RULE_TYPE_MAP[ruleId];
        if (!ruleType) {
            return false;
        }
        return (ruleId.startsWith('@typescript-eslint/') ||
            ruleId.startsWith('@lwc/') ||
            ruleType.includes('JavaScript') ||
            ruleType.includes('TypeScript') ||
            ruleType.includes('LWC'));
    }
    /**
     * Check if a rule ID is an Apex rule
     *
     * @param ruleId - The rule identifier to check
     * @returns True if the rule is for Apex code
     * @example
     * ```typescript
     * const isApex = RuleUtils.isApexRule('ApexCRUDViolation');
     * console.log(isApex); // true
     *
     * const isApexComplexity = RuleUtils.isApexRule('ApexComplexity');
     * console.log(isApexComplexity); // true
     *
     * const isJs = RuleUtils.isApexRule('no-unused-vars');
     * console.log(isJs); // false
     * ```
     */
    static isApexRule(ruleId) {
        return (RULE_TYPE_MAP[ruleId]?.includes('Apex') ||
            ruleId.startsWith('Apex') ||
            ruleId.includes('Apex'));
    }
}