@sonar-autofix/validator 0.0.1

package/index.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+
+const execAsync = promisify(exec);
+
+const DEFAULT_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+
+class Validator {
+  /**
+   * @param {object} config
+   * @param {object} config.validation
+   * @param {string[]} config.validation.build - Build commands to run
+   * @param {string[]} config.validation.lint - Lint commands to run
+   * @param {string[]} config.validation.tests - Test commands to run
+   * @param {string} [cwd] - Working directory for commands
+   */
+  constructor(config = {}, cwd = process.cwd()) {
+    const validation = config.validation || {};
+    this.commands = {
+      build: validation.build || ['npm run build'],
+      lint: validation.lint || ['npm run lint'],
+      tests: validation.tests || ['npm test'],
+    };
+    this.cwd = cwd;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+
+  /**
+   * Run a single shell command.
+   * @param {string} command
+   * @returns {Promise<{success: boolean, stdout: string, stderr: string, exitCode: number}>}
+   */
+  async runCommand(command) {
+    console.log(`[Validator] Running: ${command} (cwd: ${this.cwd})`);
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: this.cwd,
+        timeout: this.timeout,
+        maxBuffer: 10 * 1024 * 1024, // 10 MB
+      });
+      return { success: true, stdout: stdout || '', stderr: stderr || '', exitCode: 0 };
+    } catch (err) {
+      return {
+        success: false,
+        stdout: err.stdout || '',
+        stderr: err.stderr || err.message || '',
+        exitCode: err.code != null ? err.code : 1,
+      };
+    }
+  }
+
+  /**
+   * Run a list of commands sequentially.
+   * @param {string[]} commands
+   * @returns {Promise<{success: boolean, output: string, errors: string[]}>}
+   */
+  async _runCommands(commands) {
+    const outputs = [];
+    const errors = [];
+    let success = true;
+
+    for (const cmd of commands) {
+      const result = await this.runCommand(cmd);
+      if (result.stdout) outputs.push(result.stdout);
+      if (!result.success) {
+        success = false;
+        errors.push(result.stderr || `Command failed: ${cmd}`);
+      }
+    }
+
+    return { success, output: outputs.join('\n'), errors };
+  }
+
+  /**
+   * Run per-file validation using the project's configured build commands.
+   * Instead of running individual tool checks on a single file (which ignores
+   * tsconfig.json, path aliases, etc.), we run the project's own build/lint
+   * commands so validation matches the real project setup.
+   * @param {string} filePath
+   * @returns {Promise<{success: boolean, errors: string[]}>}
+   */
+  async validateFile(filePath) {
+    console.log(`[Validator] Validating after changes to: ${filePath}`);
+    const errors = [];
+    let success = true;
+
+    // Run build commands — these respect tsconfig.json, path aliases, etc.
+    for (const cmd of this.commands.build) {
+      const result = await this.runCommand(cmd);
+      if (!result.success) {
+        success = false;
+        errors.push(result.stderr || result.stdout || `Build failed: ${cmd}`);
+      }
+    }
+
+    // Run lint commands
+    for (const cmd of this.commands.lint) {
+      const result = await this.runCommand(cmd);
+      if (!result.success) {
+        success = false;
+        errors.push(result.stderr || result.stdout || `Lint failed: ${cmd}`);
+      }
+    }
+
+    return { success, errors };
+  }
+
+  /**
+   * Run all configured build commands sequentially.
+   * @returns {Promise<{success: boolean, output: string, errors: string[]}>}
+   */
+  async runBuild() {
+    console.log('[Validator] Running build commands...');
+    return this._runCommands(this.commands.build);
+  }
+
+  /**
+   * Run all configured lint commands.
+   * @returns {Promise<{success: boolean, output: string, errors: string[]}>}
+   */
+  async runLint() {
+    console.log('[Validator] Running lint commands...');
+    return this._runCommands(this.commands.lint);
+  }
+
+  /**
+   * Run all configured test commands.
+   * @returns {Promise<{success: boolean, output: string, errors: string[]}>}
+   */
+  async runTests() {
+    console.log('[Validator] Running test commands...');
+    return this._runCommands(this.commands.tests);
+  }
+
+  /**
+   * Run build, lint, and tests in sequence.
+   * @returns {Promise<{success: boolean, results: {build: object, lint: object, tests: object}}>}
+   */
+  async validateAll() {
+    console.log('[Validator] Running full validation...');
+    const build = await this.runBuild();
+    const lint = await this.runLint();
+    const tests = await this.runTests();
+
+    return {
+      success: build.success && lint.success && tests.success,
+      results: { build, lint, tests },
+    };
+  }
+
+  /**
+   * Run per-batch validations (build + tests).
+   * @returns {Promise<{success: boolean, results: {build: object, tests: object}}>}
+   */
+  async validateBatch() {
+    console.log('[Validator] Running batch validation (build + tests)...');
+    const build = await this.runBuild();
+    const tests = await this.runTests();
+
+    return {
+      success: build.success && tests.success,
+      results: { build, tests },
+    };
+  }
+}
+
+module.exports = Validator;

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@sonar-autofix/validator",
+  "version": "0.0.1",
+  "description": "Validator for the Sonar Autofix tool",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "sonar",
+    "autofix",
+    "github",
+    "validator"
+  ],
+  "author": "Sonar Autofix Team",
+  "license": "MIT"
+}