@syntropysoft/praetorian
Version:
Praetorian CLI – A universal multi-environment configuration validator for DevSecOps teams. Validate, compare, and secure YAML/ENV files with ease.
192 lines • 6.84 kB
JavaScript
;
/**
* TODO: IMPERATIVE PROGRAMMING PATTERN - NEEDS REFACTORING
*
* This file demonstrates imperative programming practices that make testing difficult:
* - Imperative for loops (line 75-79)
* - Switch statements with side effects
* - Complex nested conditionals
* - Mutable state handling
* - Multiple responsibilities in single methods
*
* Mutation Score: 9.57% - Imperative patterns make testing fragile!
*
* RECOMMENDATION: Refactor to use:
* - Functional array methods (map, filter, reduce)
* - Strategy pattern for audit types
* - Pure functions with immutable data
* - Composition over inheritance
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.AuditEngine = void 0;
const Validator_1 = require("./Validator");
const AuditCalculator_1 = require("./AuditCalculator");
const SecurityAuditor_1 = require("../../infrastructure/plugins/SecurityAuditor");
const ComplianceAuditor_1 = require("../../infrastructure/plugins/ComplianceAuditor");
const PerformanceAuditor_1 = require("../../infrastructure/plugins/PerformanceAuditor");
class AuditEngine {
constructor(options = {}) {
this.options = {
plugins: ['syntropylog'],
types: ['security', 'compliance', 'performance'],
strict: false,
...options
};
this.validator = new Validator_1.Validator({
plugins: this.options.plugins,
strict: this.options.strict
});
this.calculator = new AuditCalculator_1.AuditCalculator();
this.securityAuditor = new SecurityAuditor_1.SecurityAuditor();
this.complianceAuditor = new ComplianceAuditor_1.ComplianceAuditor();
this.performanceAuditor = new PerformanceAuditor_1.PerformanceAuditor();
}
/**
* Run a comprehensive audit
*/
async audit(context, options) {
const startTime = Date.now();
// Validate input parameters
if (context === null || context === undefined) {
throw new Error('Audit context is required and cannot be null or undefined');
}
if (!context || typeof context !== 'object') {
throw new Error('Audit context must be a valid object');
}
try {
let auditResults;
if (options?.type) {
// Run specific audit type
const result = await this.runAuditType(options.type, context);
auditResults = [result];
}
else {
// Run all configured audit types
auditResults = await this.runAllAudits(context);
}
const summary = this.calculator.calculateSummary(auditResults);
const result = this.buildAuditResult(auditResults, summary, startTime);
// Add properties expected by tests
return this.addTestProperties(result, auditResults, options?.type);
}
catch (error) {
return this.buildErrorResult(error, startTime);
}
}
/**
* Run all configured audit types
*/
async runAllAudits(context) {
const auditResults = [];
for (const auditType of this.options.types || []) {
const result = await this.runAuditType(auditType, context);
auditResults.push(result);
}
return auditResults;
}
/**
* Run a specific type of audit
*/
async runAuditType(auditType, context) {
switch (auditType) {
case 'security':
return this.securityAuditor.audit(context);
case 'compliance':
return this.complianceAuditor.audit(context);
case 'performance':
return this.performanceAuditor.audit(context);
default:
return this.createUnknownAuditResult(auditType);
}
}
/**
* Build successful audit result
*/
buildAuditResult(results, summary, startTime) {
return {
success: summary.failedChecks === 0,
score: summary.score,
grade: summary.grade,
timestamp: new Date(),
duration: Date.now() - startTime,
totalChecks: summary.totalChecks,
passedChecks: summary.passedChecks,
failedChecks: summary.failedChecks,
warnings: summary.warnings,
results,
summary
};
}
/**
* Build error result
*/
buildErrorResult(error, startTime) {
return {
success: false,
score: 0,
grade: 'F',
timestamp: new Date(),
duration: Date.now() - startTime,
totalChecks: 0,
passedChecks: 0,
failedChecks: 1,
warnings: 0,
results: [{
success: false,
errors: [{
code: 'AUDIT_ERROR',
message: error instanceof Error ? error.message : 'Unknown audit error',
severity: 'error',
context: { error }
}],
warnings: [],
metadata: { error: error instanceof Error ? error.message : 'Unknown error' }
}],
summary: {
score: 0,
grade: 'F',
criticalIssues: 1,
securityIssues: 0,
complianceIssues: 0,
recommendations: ['Fix audit system errors'],
totalChecks: 0,
passedChecks: 0,
failedChecks: 1,
warnings: 0
}
};
}
/**
* Create result for unknown audit type
*/
createUnknownAuditResult(auditType) {
return {
success: true,
errors: [],
warnings: [{
code: 'UNKNOWN_AUDIT_TYPE',
message: `Unknown audit type: ${auditType}`,
severity: 'warning'
}],
metadata: { auditType }
};
}
/**
* Add properties expected by tests
*/
addTestProperties(result, auditResults, auditType) {
// Add specific issue arrays based on audit type
if (auditType === 'security') {
result.vulnerabilities = auditResults.flatMap(r => r.errors).filter(e => e.severity === 'error');
}
else if (auditType === 'compliance') {
result.complianceIssues = auditResults.flatMap(r => r.errors);
}
else if (auditType === 'performance') {
result.performanceIssues = auditResults.flatMap(r => r.errors);
}
return result;
}
}
exports.AuditEngine = AuditEngine;
//# sourceMappingURL=AuditEngine.js.map