Merge pull request #6 from db1group/feature/add-technical-debt-indicator

Feature/add technical debt indicator

package.json

@@ -65,9 +65,10 @@
     "collectCoverageFrom": [
       "src/**/*.ts",
       "!src/infra/**",
-      "!src/api/**",
       "!src/main.ts",
-      "!src/app.module.ts"
+      "!src/**/*.module.ts",
+      "!src/**/*.controller.ts",
+      "!src/**/*.dto.ts"
     ],
     "coverageReporters": [
       "json",

sonar-project.properties

@@ -19,7 +19,7 @@ sonar.tests=test
 sonar.language=ts
 
 # Configuração do caminho de exclusão da cobertura (excluindo a pasta 'infra')
-sonar.coverage.exclusions=**/infra/**/*,  **/api/**/*, **/src/main.ts 
+sonar.coverage.exclusions=**/infra/**/*, **/src/main.ts, **/*.module.ts , **/*.controller.ts , **/*.dto.ts
 
 # Diretório onde os relatórios de cobertura são gerados
 sonar.javascript.lcov.reportPaths=coverage/lcov.info

src/app.module.ts

@@ -1,12 +1,13 @@
 import { Module } from '@nestjs/common';
-import { AppController } from './api/app.controller';
+
 import { ConfigModule } from '@nestjs/config';
 import { LOGGER } from './infra/logger/logger';
 import { ConsoleLogger } from './infra/logger/api-logger';
+import { HealthScoreModule } from './modules/health-score/health-score.module';
 
 @Module({
-  imports: [ConfigModule.forRoot()],
-  controllers: [AppController],
+  imports: [ConfigModule.forRoot(), HealthScoreModule],
+  controllers: [],
   providers: [
     {
       provide: LOGGER,

src/application/code-quality.service.ts

@@ -3,11 +3,19 @@ import {
   CompanyMeasureUsecase,
 } from './usecases/company-measure';
 
-import { QualityProvider } from '../domain/quality-provider';
+import { QualityProvider } from './quality-provider';
+import { TechnicalDebtProvider } from './technical-debt-provider';
+import { QualityMeasureResultDto } from '@/modules/health-score/quality-measure-result.dto';
 
 export class CodeQualityService {
-  constructor(private readonly qualityProvider: QualityProvider) {}
-  async generateQualityMeasure(keys?: string, keyName?: string): Promise<any> {
+  constructor(
+    private readonly qualityProvider: QualityProvider,
+    private readonly technicalDebtProvider: TechnicalDebtProvider,
+  ) { }
+  async generateQualityMeasure(
+    keys?: string,
+    keyName?: string,
+  ): Promise<QualityMeasureResultDto> {
     const projectKeys = await this.getProjectKeysByKeyName(keys, keyName);
 
     const companyMeasureInput: CompanyMeasureInput = {
@@ -17,10 +25,21 @@ export class CodeQualityService {
     const companyData = new CompanyMeasureUsecase(
       companyMeasureInput,
       this.qualityProvider,
+      this.technicalDebtProvider,
     );
+
+    const healthScore = await companyData.execute();
+
     return {
-      value: await companyData.execute(),
-      projects: projectKeys,
+      value: healthScore.value,
+      technicalDebt: healthScore.technicalDebt,
+      items: healthScore.items.map((item) => {
+        return {
+          project: item.project,
+          technicalDebt: item.technicalDebt,
+          value: item.value,
+        };
+      })
     };
   }
 

src/domain/quality-provider.ts → src/application/quality-provider.ts

@@ -1,4 +1,4 @@
-import { QualityMeasures } from './measures/QualityMeasures';
+import { QualityMeasures } from '../domain/health-score/measures/QualityMeasures';
 
 export interface QualityProvider {
   getMetricsDataFromProjectKey(projectKey: string): Promise<QualityMeasures[]>;

src/application/technical-debt-provider.ts

@@ -0,0 +1,5 @@
+import { TechnicalDebt } from '@/domain/technical-debt/TechnicalDebt';
+
+export interface TechnicalDebtProvider {
+  getTechnicalDebtFromProject(project: string): Promise<TechnicalDebt>;
+}

src/application/usecases/company-measure.ts

@@ -1,18 +1,23 @@
-import { CompanyHealthCalculator } from '@/domain/CompanyHealthScore';
-import { Project } from '../../domain/Project';
-import { QualityProvider } from 'src/domain/quality-provider';
+import { Company } from '@/domain/Company';
+import { QualityProvider } from '../quality-provider';
+import { TechnicalDebtProvider } from '../technical-debt-provider';
+import { Project } from '@/domain/Project';
+import { HealthScore } from '@/domain/HealthScore';
 
 export class CompanyMeasureUsecase {
   constructor(
     private readonly input: CompanyMeasureInput,
     private readonly qualityProviderService: QualityProvider,
+    private readonly tecnicalDebtService: TechnicalDebtProvider,
   ) {}
 
-  async execute(): Promise<any> {
+  async execute(): Promise<HealthScore> {
     const { projectKeys } = this.input;
     const projects = await this.getProjects(projectKeys);
-    const companyHealthCalculator = new CompanyHealthCalculator(projects);
-    return companyHealthCalculator.calculateHealthScore();
+    const company = new Company(projects);
+    const healthScore = company.calculateHealthScore();
+
+    return healthScore;
   }
 
   private async getProjects(projectKeys: string[]): Promise<Project[]> {
@@ -23,7 +28,11 @@ export class CompanyMeasureUsecase {
             projectKey,
           );
         if (qualityMeasures) {
-          return new Project(qualityMeasures);
+          const technicalDebt =
+            await this.tecnicalDebtService.getTechnicalDebtFromProject(
+              projectKey,
+            );
+          return new Project(projectKey, qualityMeasures, technicalDebt);
         }
       }),
     );

src/domain/Company.ts

@@ -0,0 +1,47 @@
+import { HealthScore, HealthScoreItem } from './HealthScore';
+import { Project } from './Project';
+import { NoProjectError } from './health-score/exceptions/InvalidProjectError';
+
+export class Company {
+  private readonly projects: Project[];
+
+  constructor(projects: Project[]) {
+    this.projects = projects;
+    if (this.projects.length === 0) {
+      throw new NoProjectError();
+    }
+  }
+
+  public calculateHealthScore(): HealthScore {
+    const items = this.calculateItems();
+
+    const acummulatedScore = items.reduce((acc, item) => {
+      return acc + item.value
+    }, 0);
+
+    const healthScoreRounded =
+      Math.round((acummulatedScore / this.projects.length) * 100) / 100;
+
+    const acummulatedDebt = items.reduce((acc, item) => {
+      return acc + item.technicalDebt;
+    }, 0);
+
+    return {
+      value: healthScoreRounded,
+      technicalDebt: acummulatedDebt,
+      items,
+    }
+  }
+
+  private calculateItems(): HealthScoreItem[] {
+    return this.projects.map((project) => {
+      const technicalDebt = project.calculateTechnicalDebt();
+      const value = project.calculateHealthScore();
+      return {
+        project: project.name,
+        technicalDebt,
+        value,
+      };
+    });
+  }
+}

src/domain/HealthScore.ts

@@ -0,0 +1,11 @@
+export class HealthScore {
+    value: number;
+    technicalDebt: number;
+    items: HealthScoreItem[];
+}
+
+export class HealthScoreItem {
+    project: string;
+    technicalDebt: number;
+    value: number;
+}

src/domain/Project.ts

@@ -1,11 +1,20 @@
-import { QualityMeasures } from './measures/QualityMeasures';
+import { QualityMeasures } from './health-score/measures/QualityMeasures';
+import { TechnicalDebt } from './technical-debt/TechnicalDebt';
 
 export class Project {
-  constructor(private readonly qualityMeasures: QualityMeasures[]) {}
+  constructor(
+    public readonly name: string,
+    private readonly qualityMeasures: QualityMeasures[],
+    private readonly technicalDebt: TechnicalDebt,
+  ) { }
 
   calculateHealthScore(): number {
     return this.qualityMeasures.reduce((acc, qualityMeasure) => {
       return acc + qualityMeasure.getQualityRatio();
     }, 0);
   }
+
+  calculateTechnicalDebt(): number {
+    return this.technicalDebt.calculateTechnicalDebt();
+  }
 }

src/domain/measures/QualityMeasures.ts → src/domain/health-score/measures/QualityMeasures.ts

@@ -3,6 +3,8 @@ export interface QualityMeasures {
   getQualityRatio(): number;
 }
 
+export const TECHICAL_DEBT = 'sqale_index';
+
 export enum QualityMeasuresTypes {
   RELIABILITY_RATING = 'reliability_rating',
   MANUTENABILITY_RATING = 'sqale_rating',

src/domain/technical-debt/TechnicalDebt.ts

@@ -0,0 +1,9 @@
+export class TechnicalDebt {
+  constructor(private readonly value: number) {}
+
+  calculateTechnicalDebt(): number {
+    const hour = 60;
+    const technicalDebtInHours = this.value / hour;
+    return technicalDebtInHours;
+  }
+}

src/infra/sonar/sonar-http-client.ts

@@ -1,10 +1,31 @@
 import { HttpClient } from '../http/http-client';
-import { QualityMeasures } from '../../domain/measures/QualityMeasures';
-import { SonarAdapterMetrics } from './sonar-metrics-adapter';
-import { QualityProvider } from '@/domain/quality-provider';
+import {
+  QualityMeasures,
+  TECHICAL_DEBT,
+} from '../../domain/health-score/measures/QualityMeasures';
 
-export class SonarHttpClient implements QualityProvider {
+import { QualityProvider } from '@/application/quality-provider';
+import { SonarMetricsAdapter } from './sonar-metrics-adapter';
+import { TechnicalDebtProvider } from '@/application/technical-debt-provider';
+import { TechnicalDebt } from '@/domain/technical-debt/TechnicalDebt';
+import { SonarTechicalDebtAdapter } from './sonar-techical-debt-adapter';
+
+export class SonarHttpClient implements QualityProvider, TechnicalDebtProvider {
   constructor(private readonly httpClient: HttpClient) {}
+  getTechnicalDebtFromProject(project: string): Promise<TechnicalDebt> {
+    const request = this.httpClient.get('/api/measures/component', {
+      params: {
+        component: project,
+        metricKeys: TECHICAL_DEBT,
+      },
+    });
+
+    return request.then((data: SonarMetricResponse) => {
+      if (data.component.measures.length) {
+        return new SonarTechicalDebtAdapter(data).execute();
+      }
+    });
+  }
   getProjectsFromProjectKeyName(projectKeyName: string): Promise<string[]> {
     const request = this.httpClient.get('/api/projects/search', {
       params: {
@@ -29,7 +50,7 @@ export class SonarHttpClient implements QualityProvider {
 
     return request.then((data: SonarMetricResponse) => {
       if (data.component.measures.length) {
-        return new SonarAdapterMetrics(data).execute();
+        return new SonarMetricsAdapter(data).execute();
       }
     });
   }

src/infra/sonar/sonar-metrics-adapter.ts

@@ -1,16 +1,16 @@
 import {
   QualityMeasures,
   QualityMeasuresTypes,
-} from '../../domain/measures/QualityMeasures';
+} from '../../domain/health-score/measures/QualityMeasures';
 import { SonarMetricResponse } from './sonar-http-client';
-import { ReliabilityMeasure } from '../../domain/measures/ReliabilityMeasure';
-import { CoverageQualityMeasure } from '../../domain/measures/CoverageQualityMeasure';
-import { ManutenabilityMeasure } from '../../domain/measures/ManutenabilityMeasure';
-import { SecurityRatingMeasure } from '../../domain/measures/SecurityRatingMeasure';
-import { DuplicatedLinesMeasure } from '../../domain/measures/DuplicatedLinesMeasure';
-import { SecurityReviewMeasure } from '../../domain/measures/SecurityReviewMeasure';
+import { ReliabilityMeasure } from '../../domain/health-score/measures/ReliabilityMeasure';
+import { CoverageQualityMeasure } from '../../domain/health-score/measures/CoverageQualityMeasure';
+import { ManutenabilityMeasure } from '../../domain/health-score/measures/ManutenabilityMeasure';
+import { SecurityRatingMeasure } from '../../domain/health-score/measures/SecurityRatingMeasure';
+import { DuplicatedLinesMeasure } from '../../domain/health-score/measures/DuplicatedLinesMeasure';
+import { SecurityReviewMeasure } from '../../domain/health-score/measures/SecurityReviewMeasure';
 
-export class SonarAdapterMetrics {
+export class SonarMetricsAdapter {
   constructor(private readonly sonarResponse: SonarMetricResponse) {}
   execute(): QualityMeasures[] {
     const healthPanelMetrics = Object.values(QualityMeasuresTypes);

src/infra/sonar/sonar-techical-debt-adapter.ts

@@ -0,0 +1,17 @@
+import { TECHICAL_DEBT } from '../../domain/health-score/measures/QualityMeasures';
+import { SonarMetricResponse } from './sonar-http-client';
+
+import { TechnicalDebt } from '@/domain/technical-debt/TechnicalDebt';
+
+export class SonarTechicalDebtAdapter {
+  constructor(private readonly sonarResponse: SonarMetricResponse) {}
+  execute(): TechnicalDebt {
+    const sonarMeasures = this.sonarResponse.component.measures;
+
+    const technicalDebtValue = sonarMeasures.find(
+      (sonarMeasure) => sonarMeasure.metric === TECHICAL_DEBT,
+    );
+
+    return new TechnicalDebt(Number(technicalDebtValue.value));
+  }
+}

src/main.ts

@@ -1,9 +1,6 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 
-import cluster from 'cluster';
-import os from 'os';
-
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 
 const port = process.env.PORT || 3000;
@@ -19,23 +16,4 @@ async function bootstrap() {
   await app.listen(port);
 }
 
-export class AppClusterService {
-  static clusterize(callback: Function): void {
-    const numCPUs = os.cpus().length;
-
-    if (cluster.isPrimary) {
-      console.log(`Master server started on ${process.pid}`);
-      for (let i = 0; i < numCPUs; i++) {
-        cluster.fork();
-      }
-      cluster.on('exit', (worker) => {
-        console.log(`Worker ${worker.process.pid} died. Restarting`);
-        cluster.fork();
-      });
-    } else {
-      console.log(`Cluster server started on ${process.pid}`);
-      callback();
-    }
-  }
-}
-AppClusterService.clusterize(bootstrap);
+bootstrap();