Integration of code quality inspection tools

In a Koa2 project, integrating code quality inspection tools can effectively improve code standardization and maintainability. Through automated checks, teams can quickly identify potential issues, reduce low-level errors, and unify code style. Below, we will elaborate step by step from tool selection, configuration to practical application.

Selection of Code Quality Inspection Tools

For Koa2, a Node.js framework, commonly used code inspection tools include ESLint, Prettier, and Husky. ESLint handles syntax checking, Prettier manages code formatting, and Husky triggers checks during Git commits. For example:

// Typical dependencies in package.json
{
  "devDependencies": {
    "eslint": "^8.56.0",
    "prettier": "^3.2.5",
    "husky": "^9.0.11",
    "lint-staged": "^15.2.2"
  }
}

For TypeScript projects, additional dependencies like @typescript-eslint/parser and @typescript-eslint/eslint-plugin are required. Teams can combine tools based on the project's tech stack, such as Airbnb or Standard style guides.

Detailed ESLint Configuration

Create an .eslintrc.js configuration file in the project root directory. For Koa2, the following rules are recommended:

module.exports = {
  env: {
    node: true,
    es2021: true
  },
  extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
  parser: '@typescript-eslint/parser',
  parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module'
  },
  rules: {
    'no-console': process.env.NODE_ENV === 'production' ? 'error' : 'warn',
    'no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
    '@typescript-eslint/explicit-function-return-type': 'off',
    'indent': ['error', 2, { SwitchCase: 1 }]
  }
};

Use the --fix parameter to automatically fix some issues:

npx eslint src --ext .ts,.js --fix

Collaboration Between Prettier and ESLint

When using both Prettier and ESLint, install eslint-config-prettier to avoid rule conflicts. Configuration example:

// .prettierrc
{
  "semi": true,
  "singleQuote": true,
  "printWidth": 100,
  "trailingComma": "all"
}

Extend Prettier in the ESLint configuration:

// .eslintrc.js
extends: [
  'eslint:recommended',
  'plugin:@typescript-eslint/recommended',
  'prettier'
]

Automated Checks During Git Commits

Implement pre-commit checks using Husky and lint-staged:

// package.json
{
  "scripts": {
    "prepare": "husky install",
    "lint-staged": "lint-staged"
  },
  "lint-staged": {
    "*.{js,ts}": ["eslint --fix", "prettier --write"]
  }
}

Initialize Husky hooks:

npx husky add .husky/pre-commit "npm run lint-staged"

Practical Case for Custom Rules

For Koa2 middleware-specific checks, custom rules can be added. For example, enforcing middleware to return a Promise:

// eslint-plugin-koa2-rules.js
module.exports = {
  rules: {
    'require-async-middleware': {
      create(context) {
        return {
          CallExpression(node) {
            if (node.callee.name === 'use') {
              const arg = node.arguments[0];
              if (arg && arg.async !== true) {
                context.report({
                  node,
                  message: 'Koa2 middleware should use async functions'
                });
              }
            }
          }
        };
      }
    }
  }
};

Enable in the configuration:

// .eslintrc.js
plugins: ['koa2-rules'],
rules: {
  'koa2-rules/require-async-middleware': 'error'
}

Quality Checks in Continuous Integration

Configure automated checks in GitHub Actions:

# .github/workflows/lint.yml
name: Lint
on: [push, pull_request]
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci
      - run: npm run lint
      - run: npm test

Performance Optimization Checks

Add special checks for Koa2 performance-critical paths:

// Detect unclosed database connections
rules: {
  'no-unclosed-connection': {
    create(context) {
      return {
        'CallExpression[callee.property.name="getConnection"]'(node) {
          if (!findMatchingRelease(node)) {
            context.report({
              node,
              message: 'Database connection not released'
            });
          }
        }
      };
    }
  }
}

Error Handling Standards

Enforce the use of a unified error-handling middleware in Koa2 projects:

rules: {
  'error-handler-middleware': {
    create(context) {
      let hasErrorHandler = false;
      return {
        'CallExpression[callee.property.name="use"]'(node) {
          if (isErrorHandler(node.arguments[0])) {
            hasErrorHandler = true;
          }
        },
        'Program:exit'() {
          if (!hasErrorHandler) {
            context.report({
              loc: { line: 1, column: 1 },
              message: 'No error-handling middleware found'
            });
          }
        }
      };
    }
  }
}

Integration with Testing Frameworks

Add code quality checks in Jest tests:

// jest.config.js
module.exports = {
  // ...
  setupFilesAfterEnv: ['./test/setup.js']
};

// test/setup.js
beforeAll(() => {
  if (process.env.CI === 'true') {
    const { execSync } = require('child_process');
    try {
      execSync('npm run lint', { stdio: 'inherit' });
    } catch {
      process.exit(1);
    }
  }
});

Generating Visual Reports

Use ESLint's HTML reporter plugin:

npm install eslint-html-reporter --save-dev

Configure HTML report output:

// .eslintrc.js
settings: {
  'html-reporter': {
    outputPath: 'reports/eslint-report.html'
  }
}

Run the command:

npx eslint src --format html --output-file reports/eslint-report.html

Custom Formatting Rules

Special formatting requirements for Koa2 route definitions:

// .prettierrc
{
  "koaRouteIndent": 2,
  "overrides": [
    {
      "files": ["**/routes/*.ts"],
      "options": {
        "printWidth": 120,
        "arrowParens": "avoid"
      }
    }
  ]
}

Incremental Refactoring of Legacy Code

For existing projects, configure checks to target only new code:

// .eslintrc.js
rules: {
  'no-var': 'error',
  'prefer-const': ['error', { ignoreReadBeforeAssign: true }]
}

Combine with Git change checks:

npx eslint $(git diff --name-only HEAD..origin/main --diff-filter=ACM | grep '\.ts$')