Technical Debt Management

# sonar-project.properties
sonar.projectKey=my-project
sonar.sourceEncoding=UTF-8

# Analysis Parameters
sonar.sources=src
sonar.tests=test
sonar.coverage.exclusions=**/*.test.ts
sonar.cpd.exclusions=**/*.spec.ts

# Quality Gates
sonar.qualitygate.wait=true

# Code Smells
sonar.issue.ignore.multicriteria=e1,e2
sonar.issue.ignore.multicriteria.e1.ruleKey=typescript:S1541
sonar.issue.ignore.multicriteria.e1.resourceKey=src/legacy/**/*
sonar.issue.ignore.multicriteria.e2.ruleKey=typescript:S3776
sonar.issue.ignore.multicriteria.e2.resourceKey=src/complex-logic/**/*

# Duplications
sonar.cpd.typescript.minimumLines=5
sonar.cpd.typescript.minimumTokens=100

# Test Coverage
sonar.javascript.lcov.reportPaths=coverage/lcov.info
sonar.testExecutionReportPaths=test-report.xml

interface CodeMetrics {
    complexity: number;
    linesOfCode: number;
    duplications: number;
    coverage: number;
    documentation: number;
}

class TechnicalDebtScanner {
    private readonly thresholds = {
        complexity: 10,
        duplications: 3,
        coverage: 80,
        documentation: 70
    };

    scanFile(
        filePath: string,
        metrics: CodeMetrics
    ): DebtAssessment {
        const issues: DebtIssue[] = [];
        const score = this.calculateDebtScore(metrics);

        if (metrics.complexity > this.thresholds.complexity) {
            issues.push({
                type: 'Complexity',
                severity: 'High',
                description: 'Excessive cyclomatic complexity',
                recommendation: 'Consider breaking down complex methods'
            });
        }

        if (metrics.duplications > this.thresholds.duplications) {
            issues.push({
                type: 'Duplication',
                severity: 'Medium',
                description: 'Code duplication detected',
                recommendation: 'Extract common code into shared functions'
            });
        }

        if (metrics.coverage < this.thresholds.coverage) {
            issues.push({
                type: 'Coverage',
                severity: 'High',
                description: 'Insufficient test coverage',
                recommendation: 'Add unit tests for uncovered code'
            });
        }

        if (metrics.documentation < this.thresholds.documentation) {
            issues.push({
                type: 'Documentation',
                severity: 'Medium',
                description: 'Poor documentation coverage',
                recommendation: 'Add JSDoc comments and improve documentation'
            });
        }

        return {
            filePath,
            debtScore: score,
            issues,
            metrics
        };
    }

    private calculateDebtScore(metrics: CodeMetrics): number {
        const weights = {
            complexity: 0.3,
            duplications: 0.2,
            coverage: 0.3,
            documentation: 0.2
        };

        return (
            (metrics.complexity * weights.complexity) +
            (metrics.duplications * weights.duplications) +
            ((100 - metrics.coverage) * weights.coverage) +
            ((100 - metrics.documentation) * weights.documentation)
        );
    }
}

interface DebtItem {
    id: string;
    category: 'code' | 'design' | 'infrastructure' | 'testing';
    description: string;
    impact: number; // 1-10
    effort: number; // Story points
    created: Date;
}

class DebtTracker {
    private items: Map = new Map();

    addDebtItem(item: DebtItem): void {
        this.items.set(item.id, item);
    }

    calculateTotalDebt(): number {
        let total = 0;
        for (const item of this.items.values()) {
            total += this.calculateDebtCost(item);
        }
        return total;
    }

    private calculateDebtCost(item: DebtItem): number {
        const ageInMonths = this.calculateAgeInMonths(item.created);
        const interestRate = 1.1; // 10% monthly compound interest
        
        return item.effort * Math.pow(interestRate, ageInMonths);
    }

    generateReport(): DebtReport {
        const totalDebt = this.calculateTotalDebt();
        const itemsByCategory = this.groupByCategory();
        const prioritizedItems = this.prioritizeItems();

        return {
            totalDebt,
            itemsByCategory,
            prioritizedItems,
            timestamp: new Date()
        };
    }

    private groupByCategory(): Record {
        const groups: Record = {
            code: [],
            design: [],
            infrastructure: [],
            testing: []
        };

        for (const item of this.items.values()) {
            groups[item.category].push(item);
        }

        return groups;
    }

    private prioritizeItems(): DebtItem[] {
        return Array.from(this.items.values())
            .sort((a, b) => {
                const scoreA = a.impact * this.calculateDebtCost(a);
                const scoreB = b.impact * this.calculateDebtCost(b);
                return scoreB - scoreA;
            });
    }

    private calculateAgeInMonths(created: Date): number {
        const now = new Date();
        const diffTime = Math.abs(now.getTime() - created.getTime());
        return Math.ceil(diffTime / (1000 * 60 * 60 * 24 * 30));
    }
}

// Before Refactoring
class UserService {
    private db: Database;
    private logger: Logger;
    private mailer: EmailService;

    async createUser(userData: any) {
        // Input validation
        if (!userData.email || !userData.password) {
            throw new Error('Invalid user data');
        }

        // Check if user exists
        const existingUser = await this.db.query(
            'SELECT * FROM users WHERE email = ?',
            [userData.email]
        );
        if (existingUser) {
            throw new Error('User already exists');
        }

        // Hash password
        const hashedPassword = await bcrypt.hash(userData.password, 10);

        // Create user
        const user = await this.db.query(
            'INSERT INTO users (email, password) VALUES (?, ?)',
            [userData.email, hashedPassword]
        );

        // Send welcome email
        await this.mailer.sendEmail({
            to: userData.email,
            subject: 'Welcome',
            body: 'Welcome to our platform!'
        });

        // Log action
        this.logger.info('New user created', { userId: user.id });

        return user;
    }
}

// After Refactoring
interface UserData {
    email: string;
    password: string;
}

class UserValidator {
    validate(userData: UserData): void {
        if (!userData.email || !userData.password) {
            throw new ValidationError('Invalid user data');
        }
    }
}

class UserRepository {
    constructor(private db: Database) {}

    async findByEmail(email: string): Promise {
        return this.db.query(
            'SELECT * FROM users WHERE email = ?',
            [email]
        );
    }

    async create(email: string, hashedPassword: string): Promise {
        return this.db.query(
            'INSERT INTO users (email, password) VALUES (?, ?)',
            [email, hashedPassword]
        );
    }
}

class PasswordService {
    async hash(password: string): Promise {
        return bcrypt.hash(password, 10);
    }
}

class UserService {
    constructor(
        private validator: UserValidator,
        private repository: UserRepository,
        private passwordService: PasswordService,
        private mailer: EmailService,
        private logger: Logger
    ) {}

    async createUser(userData: UserData): Promise {
        this.validator.validate(userData);
        await this.ensureUserDoesNotExist(userData.email);
        
        const hashedPassword = await this.passwordService
            .hash(userData.password);
        
        const user = await this.repository
            .create(userData.email, hashedPassword);
        
        await this.sendWelcomeEmail(userData.email);
        this.logUserCreation(user.id);
        
        return user;
    }

    private async ensureUserDoesNotExist(email: string): Promise {
        const existingUser = await this.repository.findByEmail(email);
        if (existingUser) {
            throw new DuplicateUserError('User already exists');
        }
    }

    private async sendWelcomeEmail(email: string): Promise {
        await this.mailer.sendEmail({
            to: email,
            subject: 'Welcome',
            body: 'Welcome to our platform!'
        });
    }

    private logUserCreation(userId: string): void {
        this.logger.info('New user created', { userId });
    }
}