refactor: separate api clients from services (#304)

Author: JulienMessageIppon

plugins/02-irocalcApi.ts

@@ -19,32 +19,36 @@ import { createFetch } from "ofetch";
 import { defineNuxtPlugin } from "#app";
 import AWSDataCenterService from "../service/awsDataCenterService";
 import CarbonService from "~/service/carbonService";
-import CatalogService from "~/service/catalogService";
-import AWSInstanceService from "~/service/awsInstanceService";
-import AdminService from "~/service/adminService";
+import CatalogApiClient from "~/service/api/catalogApiClient";
+import AWSInstanceApiClient from "~/service/api/AWSInstanceApiClient";
+import AdminApiClient from "~/service/api/adminApiClient";
 import { useAuth } from "vue-clerk";
-import InfrastructureService from "~/service/infrastructureService";
-import CloudServiceProviderSvc from "~/service/CloudServiceProviderService";
-import ServiceConfigurationSettingSvc from "~/service/ServiceConfigurationSettingService";
-import ComponentService from "~/service/componentService";
+import InfrastructureApiClient from "~/service/api/infrastructureApiClient";
+import CloudServiceProviderApiClient from "~/service/api/CloudServiceProviderApiClient";
+import ServiceConfigurationSettingApiClient from "~/service/api/ServiceConfigurationSettingApiClient";
+import ComponentApiClient from "~/service/api/componentApiClient";
 import AnalysisService from "~/service/analysisService";
-import CurService from "~/service/curService";
+import CurApiClient from "~/service/api/curApiClient";
 import TokenService from "~/service/tokenService";
 import ScanService from "~/service/scanService";
+import { AnalysisApiClient } from "~/service/api/analysisApiClient";
+import { AWSDataCenterApiClient } from "~/service/api/AWSDataCenterApiClient";
+import { IrocalcCarbonApiClient } from "~/service/api/irocalcCarbonApiClient";
+import ScanApiClient from "~/service/api/scanApiClient";
 
 /** ApiInstance interface provides us with good typing */
 interface IApiInstance {
   awsDataCenter: AWSDataCenterService;
   carbon: CarbonService;
-  catalogService: CatalogService;
-  instanceType: AWSInstanceService;
-  adminService: AdminService;
-  infrastructureService: InfrastructureService;
-  componentService: ComponentService;
-  cloudServiceProviderService: CloudServiceProviderSvc;
-  serviceConfigurationSettingSvc: ServiceConfigurationSettingSvc;
+  catalogService: CatalogApiClient;
+  instanceType: AWSInstanceApiClient;
+  adminService: AdminApiClient;
+  infrastructureService: InfrastructureApiClient;
+  componentService: ComponentApiClient;
+  cloudServiceProviderService: CloudServiceProviderApiClient;
+  serviceConfigurationSettingSvc: ServiceConfigurationSettingApiClient;
   analysisService: AnalysisService;
-  curService: CurService;
+  curService: CurApiClient;
   tokenService: TokenService;
   scanService: ScanService;
 }
@@ -95,23 +99,30 @@ export default defineNuxtPlugin({
       },
     });
 
+    const infrastructureApiClient = new InfrastructureApiClient(apiFetcher);
+
     /** an object containing all repositories we need to expose */
     const modules: IApiInstance = {
-      carbon: new CarbonService(apiFetcher),
-      awsDataCenter: new AWSDataCenterService(apiFetcher),
-      catalogService: new CatalogService(apiFetcher),
-      instanceType: new AWSInstanceService(apiFetcher),
-      adminService: new AdminService(apiFetcher),
-      infrastructureService: new InfrastructureService(apiFetcher),
-      componentService: new ComponentService(apiFetcher),
-      cloudServiceProviderService: new CloudServiceProviderSvc(apiFetcher),
-      serviceConfigurationSettingSvc: new ServiceConfigurationSettingSvc(
+      carbon: new CarbonService(new IrocalcCarbonApiClient(apiFetcher)),
+      awsDataCenter: new AWSDataCenterService(
+        infrastructureApiClient,
+        new AWSDataCenterApiClient(apiFetcher),
+      ),
+      catalogService: new CatalogApiClient(apiFetcher),
+      instanceType: new AWSInstanceApiClient(apiFetcher),
+      adminService: new AdminApiClient(apiFetcher),
+      infrastructureService: infrastructureApiClient,
+      componentService: new ComponentApiClient(apiFetcher),
+      cloudServiceProviderService: new CloudServiceProviderApiClient(
+        apiFetcher,
+      ),
+      serviceConfigurationSettingSvc: new ServiceConfigurationSettingApiClient(
         apiFetcher,
       ),
-      analysisService: new AnalysisService(apiFetcher),
-      curService: new CurService(apiFetcher),
+      analysisService: new AnalysisService(new AnalysisApiClient(apiFetcher)),
+      curService: new CurApiClient(apiFetcher),
       tokenService: new TokenService(apiFetcher),
-      scanService: new ScanService(apiFetcher),
+      scanService: new ScanService(new ScanApiClient(apiFetcher)),
     };
 
     return {

service/analysisService.ts

@@ -16,26 +16,30 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import HttpFactory from "./factory/httpFactory";
 import type { ReportStatus } from "~/type/ReportStatus";
 import type { Payload } from "~/type/Payload";
+import type { AnalysisApiClient } from "~/service/api/analysisApiClient";
 
-type Analysis = {
+export type Analysis = {
   status: ReportStatus;
   id: string;
   dateCreation: string;
   co2Gr: number;
 };
 
-type AnalysisDetails = Analysis & {
+export type AnalysisDetails = Analysis & {
   payloads: Payload[];
 };
 
-class AnalysisService extends HttpFactory {
-  private readonly RESOURCE = "/api/analysis";
+class AnalysisService {
+  private readonly analysisApiClient: AnalysisApiClient;
+
+  constructor(analysisApiClient: AnalysisApiClient) {
+    this.analysisApiClient = analysisApiClient;
+  }
 
   async getAllAnalyses() {
-    const analyses = await this.getCall<Analysis[]>(this.RESOURCE);
+    const analyses = await this.analysisApiClient.getAllAnalyses();
     return analyses.map((analysis) => ({
       ...analysis,
       co2Converted: convertEstimateToBestMassUnit(analysis.co2Gr),
@@ -44,7 +48,7 @@ class AnalysisService extends HttpFactory {
 
   async getAnalysisById(analysisId: string) {
     const estimated = (
-      await this.getCall<AnalysisDetails>(`${this.RESOURCE}/${analysisId}`)
+      await this.analysisApiClient.getAnalysisById(analysisId)
     ).payloads.map((p) => ({
       label: p.name,
       co2Gr: p.carbonGramFootprint,
@@ -59,7 +63,7 @@ class AnalysisService extends HttpFactory {
   }
 
   async deleteAnalysis(analysisId: string): Promise<void> {
-    return await this.deleteCall(`${this.RESOURCE}/${analysisId}`);
+    return await this.analysisApiClient.deleteAnalysis(analysisId);
   }
 }
 

service/api/AWSDataCenterApiClient.ts

@@ -0,0 +1,10 @@
+import ApiClient from "~/service/api/apiClient";
+import type { Region } from "~/type/Region";
+
+export class AWSDataCenterApiClient extends ApiClient {
+  private readonly RESOURCE = "/api/cloud-service-providers";
+
+  async getAllAWSDataCenter(cspId: string): Promise<Region[]> {
+    return await this.getCall<Region[]>(`${this.RESOURCE}/${cspId}/regions`);
+  }
+}

service/awsInstanceService.ts service/api/AWSInstanceApiClient.tsservice/awsInstanceService.ts renamed to service/api/AWSInstanceApiClient.ts

@@ -15,10 +15,10 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-import HttpFactory from "./factory/httpFactory";
+import ApiClient from "./apiClient";
 import type { EC2InstanceType } from "~/type/ec2InstanceType";
 
-class AWSInstanceService extends HttpFactory {
+class AWSInstanceApiClient extends ApiClient {
   private readonly RESOURCE = "/api/awsInstanceType";
 
   async getAllInstanceByType(
@@ -28,4 +28,4 @@ class AWSInstanceService extends HttpFactory {
   }
 }
 
-export default AWSInstanceService;
+export default AWSInstanceApiClient;

service/CloudServiceProviderService.ts …ice/api/CloudServiceProviderApiClient.tsservice/CloudServiceProviderService.ts renamed to service/api/CloudServiceProviderApiClient.ts service/CloudServiceProviderService.ts renamed to service/api/CloudServiceProviderApiClient.ts

@@ -15,11 +15,11 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-import HttpFactory from "./factory/httpFactory";
+import ApiClient from "./apiClient";
 import type { CloudServiceProvider } from "~/type/infrastructure/CloudServiceProvider";
 import type { CloudServiceProviderService } from "~/type/infrastructure/CloudServiceProviderService";
 
-class CloudServiceProviderSvc extends HttpFactory {
+class CloudServiceProviderApiClient extends ApiClient {
   private readonly RESOURCE = "/api/cloud-service-providers";
 
   async getCloudServiceProviders(): Promise<CloudServiceProvider[]> {
@@ -35,4 +35,4 @@ class CloudServiceProviderSvc extends HttpFactory {
   }
 }
 
-export default CloudServiceProviderSvc;
+export default CloudServiceProviderApiClient;

…ce/ServiceConfigurationSettingService.ts …/ServiceConfigurationSettingApiClient.tsservice/ServiceConfigurationSettingService.ts renamed to service/api/ServiceConfigurationSettingApiClient.ts service/ServiceConfigurationSettingService.ts renamed to service/api/ServiceConfigurationSettingApiClient.ts

@@ -15,10 +15,10 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-import HttpFactory from "./factory/httpFactory";
+import ApiClient from "./apiClient";
 import type { ServiceConfigurationSetting } from "~/type/infrastructure/ServiceConfigurationSetting";
 
-class ServiceConfigurationSettingSvc extends HttpFactory {
+class ServiceConfigurationSettingApiClient extends ApiClient {
   private readonly RESOURCE = "/api/service-configuration-settings";
 
   async findAllConfigurationSettingsByServiceId(
@@ -30,4 +30,4 @@ class ServiceConfigurationSettingSvc extends HttpFactory {
   }
 }
 
-export default ServiceConfigurationSettingSvc;
+export default ServiceConfigurationSettingApiClient;

service/adminService.ts service/api/adminApiClient.tsservice/adminService.ts renamed to service/api/adminApiClient.ts

@@ -15,12 +15,12 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-import HttpFactory from "./factory/httpFactory";
+import ApiClient from "./apiClient";
 
-class AdminService extends HttpFactory {
+class AdminApiClient extends ApiClient {
   async evictRegionCache(): Promise<void> {
     return this.deleteCall(`/actuator/caches/regions`);
   }
 }
 
-export default AdminService;
+export default AdminApiClient;

service/api/analysisApiClient.ts

@@ -0,0 +1,21 @@
+import ApiClient from "~/service/api/apiClient";
+import type { Analysis } from "../analysisService";
+import type { AnalysisDetails } from "~/service/analysisService";
+
+export class AnalysisApiClient extends ApiClient {
+  private readonly RESOURCE = "/api/analysis";
+
+  async getAllAnalyses(): Promise<Analysis[]> {
+    return await this.getCall<Analysis[]>(this.RESOURCE);
+  }
+
+  async getAnalysisById(analysisId: string): Promise<AnalysisDetails> {
+    return await this.getCall<AnalysisDetails>(
+      `${this.RESOURCE}/${analysisId}`,
+    );
+  }
+
+  async deleteAnalysis(analysisId: string): Promise<void> {
+    return await this.deleteCall(`${this.RESOURCE}/${analysisId}`);
+  }
+}

service/factory/httpFactory.ts service/api/apiClient.tsservice/factory/httpFactory.ts renamed to service/api/apiClient.ts

@@ -17,7 +17,7 @@
  */
 import type { ofetch } from "ofetch";
 
-class HttpFactory {
+class ApiClient {
   private readonly $fetch: typeof ofetch;
 
   constructor(fetcher: typeof ofetch) {
@@ -86,4 +86,4 @@ class HttpFactory {
   }
 }
 
-export default HttpFactory;
+export default ApiClient;

service/catalogService.ts service/api/catalogApiClient.tsservice/catalogService.ts renamed to service/api/catalogApiClient.ts

@@ -15,12 +15,12 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-import HttpFactory from "~/service/factory/httpFactory";
 import { Availability } from "~/type/Availability";
 import type { ServiceCatalog } from "~/type/ServiceCatalog";
 import type { ServiceDescription } from "~/type/ServiceDescription";
+import ApiClient from "~/service/api/apiClient";
 
-class CatalogService extends HttpFactory {
+class CatalogApiClient extends ApiClient {
   private readonly RESOURCE = "/api/public/v2/catalog";
 
   async getAllServices(): Promise<ServiceCatalog[]> {
@@ -39,4 +39,4 @@ class CatalogService extends HttpFactory {
   }
 }
 
-export default CatalogService;
+export default CatalogApiClient;