自定义ESLint规则并整合到SonarQube

/**
 * @fileoverview 限制SQL中LEFT JOIN的最大数量
 * @author xiaowu
 */
"use strict";

const { joinValid } = require("../utilities/index");

/** @type {import('eslint').Rule.RuleModule} */
module.exports = {
    meta: {
        type: 'problem',
        docs: {
            description: "限制SQL文件中的LEFT JOIN数量",
            recommended: true,
            url: null,
        },
        fixable: 'code',
        schema: [
            {
                type: 'object',
                properties: {
                    maxLeftJoin: {
                        type: 'number',
                    },
                },
                additionalProperties: false,
            },
        ], 
        messages: {
            exceedMaxJoin: 'SQL文件中的{{joinType}}数量({{count}})超过限制({{max}}次)',
        },
    },

    create(context) {
        return {
            ExportNamedDeclaration(node) {
                if (node.declaration?.declarations?.length) {
                    node.declaration.declarations.forEach(declaration => {
                        joinValid(declaration.init, context, 'left join');
                    });
                }
            },
        };
    },
};

/**
 * 验证JOIN语句数量
 * @param {Object} node - AST节点
 * @param {Object} context - ESLint上下文
 * @param {string} joinStr - JOIN类型（如'left join'）
 */
function joinValid(node, context, joinStr) {
    if (!node) {
        return;
    }

    // 获取配置的最大JOIN数量，默认为3
    let maxJoin = 3;
    if (context.options[0]?.maxLeftJoin !== undefined && joinStr === 'left join') {
        maxJoin = context.options[0].maxLeftJoin;
    }
    if (context.options[0]?.maxRightJoin !== undefined && joinStr === 'right join') {
        maxJoin = context.options[0].maxRightJoin;
    }

    // 处理模板字符串
    if (node.type === 'TaggedTemplateExpression') {
        node = node.quasi;
    }

    let literal = "";

    // 处理箭头函数（带参数的SQL）
    if (node.type === 'ArrowFunctionExpression') {
        if (node.body.type === 'TemplateLiteral' && node.body.quasis.length) {
            literal = node.body.quasis.map(quasi => quasi.value.raw).join('');
        }
    }
    // 处理模板字面量（不带参数的SQL）
    else if (node.type === 'TemplateLiteral' && node.quasis.length) {
        literal = node.quasis.map(quasi => quasi.value.raw).join('');
    }

    // 检查是否为SQL查询
    if (literal.length > 0 && isSqlQuery(literal)) {
        literal = sqlFormat(literal);
        const joinCount = literal.split(joinStr).length - 1;

        if (joinCount > maxJoin) {
            context.report({
                node,
                message: `SQL文件中的${joinStr}数量超过${maxJoin}次`,
            });
        }
    }
}

module.exports = {
    joinValid,
};

/**
 * @fileoverview 最大LEFT JOIN数量测试
 * @author xiaowu
 */
"use strict";

const rule = require("../../../lib/rules/no-more-left-join");
const RuleTester = require("eslint").RuleTester;

const ruleTester = new RuleTester({
    parserOptions: {
        sourceType: 'module',
        ecmaVersion: 2015,
    },
});

ruleTester.run("no-more-left-join", rule, {
    // 应该报错的测试用例
    invalid: [
        {
            code: `export const getContractsSql = \`
SELECT * 
FROM x 
LEFT JOIN a ON a.id = x.id 
LEFT JOIN b ON b.id = x.id 
WHERE 1=1 \${sqlConditions}
ORDER BY update_time DESC  
\${sqlLimit}
\`;`,
            options: [{ maxLeftJoin: 1 }],
            errors: [{
                message: 'SQL文件中的 left join 数量超过 1 次',
            }],
        },
    ],

    // 不应该报错的测试用例
    valid: [
        {
            code: "import {inspect} from 'util';",
            options: [{ maxLeftJoin: 1 }],
        },
        {
            code: `export const getSimpleSql = \`
SELECT * 
FROM x 
LEFT JOIN a ON a.id = x.id
WHERE 1=1
\`;`,
            options: [{ maxLeftJoin: 1 }],
        },
    ],
});

module.exports = {
  // ...其他配置
  
  // 引入插件（eslint-plugin-前缀可省略）
  plugins: ['demo'],
  
  // 配置规则
  rules: {
    // 限制LEFT JOIN最大数量为1次
    "demo/no-more-left-join": ["error", { maxLeftJoin: 1 }],
  },
  
  // ...其他配置
};