Linter fixes after husky has been added

api/src/engine/connectors/datashield/main.connector.ts

-import { HttpService } from "@nestjs/axios";
-import { Request } from "express";
-import { Observable } from "rxjs";
-import { IEngineOptions, IEngineService } from "src/engine/engine.interfaces";
+import { HttpService } from '@nestjs/axios';
+import { Request } from 'express';
+import { Observable } from 'rxjs';
+import { IEngineOptions, IEngineService } from 'src/engine/engine.interfaces';
 
 export default class DataShieldService implements IEngineService {
-    constructor(private readonly options: IEngineOptions, private readonly httpService: HttpService) { }
-
-    demo(): string {
-        return "datashield";
-    }
-    
-    getExperiment(uuid: string): Observable<string> {
-        throw new Error("Method not implemented.");
-    }
-
-    deleteExperiment(uuid: string, request: Request): Observable<string> {
-        throw new Error("Method not implemented.");
-    }
-
-    editExperiment(uuid: string, request: Request): Observable<string> {
-        throw new Error("Method not implemented.");
-    }
-
-    startExperimentTransient(request: Request): Observable<string> {
-        throw new Error("Method not implemented.");
-    }
-
-    startExperiment(request: Request): Observable<string> {
-        throw new Error("Method not implemented.");
-    }
-    
-    getExperiments(): Observable<string> {
-        throw new Error("Method not implemented.");
-    }
-
-    getAlgorithms(): Observable<string> {
-        throw new Error("Method not implemented.");
-    }
-}
+  constructor(
+    private readonly options: IEngineOptions,
+    private readonly httpService: HttpService,
+  ) {}
+
+  demo(): string {
+    return 'datashield';
+  }
+
+  getExperiment(uuid: string): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  deleteExperiment(uuid: string, request: Request): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  editExperiment(uuid: string, request: Request): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  startExperimentTransient(request: Request): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  startExperiment(request: Request): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  getExperiments(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  getAlgorithms(): Observable<string> {
\ No newline at end of file
+    throw new Error('Method not implemented.');
+  }
+}

api/src/engine/connectors/exareme/main.connector.ts

-import { HttpService } from "@nestjs/axios";
-import { Request } from "express";
-import { map, Observable } from "rxjs";
-import { IEngineOptions, IEngineService } from "src/engine/engine.interfaces";
+import { HttpService } from '@nestjs/axios';
+import { Request } from 'express';
+import { map, Observable } from 'rxjs';
+import { IEngineOptions, IEngineService } from 'src/engine/engine.interfaces';
 
 export default class ExaremeService implements IEngineService {
-    constructor(private readonly options: IEngineOptions, private readonly httpService: HttpService) { }
-
-    demo(): string {
-        return "exareme"
-    }
-
-    getExperiment(uuid: string): Observable<string> {
-        const path = this.options.baseurl + `experiments/${uuid}`;
-
-        return this.httpService.get<string>(path).pipe(
-            map(response => response.data)
-        );
-    }
-
-    deleteExperiment(uuid: string): Observable<string> {
-        const path = this.options.baseurl + `experiments/${uuid}`;
-
-        return this.httpService.delete(path).pipe(
-            map(response => response.data)
-        )
-    }
-
-    editExperiment(uuid: string, request: Request): Observable<string> {
-        const path = this.options.baseurl + `experiments/${uuid}`;
-
-        return this.httpService.post(path,request.body).pipe(
-            map(response => response.data)
-        )
-    }
-
-    startExperimentTransient(request: Request): Observable<string> {
-        const path = this.options.baseurl + "experiments/transient";
-
-        return this.httpService.post(path, request.body).pipe(
-            map(response => response.data)
-        )
-    }
-
-    startExperiment(request: Request): Observable<string> {
-        const path = this.options.baseurl + "experiments";
-
-        return this.httpService.post(path, request.body).pipe(
-            map(response => response.data)
-        )
-    }
-
-    getExperiments(): Observable<string> {
-        const path = this.options.baseurl + "experiments";
-
-        return this.httpService.get<string>(path).pipe(
-            map(response => response.data)
-        );
-    }
-
-    getAlgorithms(): Observable<string> {
-        const path = this.options.baseurl + "algorithms";
-        
-        return this.httpService.get<string>(path).pipe(
-            map(response => response.data)
-        );
-    }
-}
+  constructor(
+    private readonly options: IEngineOptions,
+    private readonly httpService: HttpService,
+  ) {}
+
+  demo(): string {
+    return 'exareme';
+  }
+
+  getExperiment(uuid: string): Observable<string> {
+    const path = this.options.baseurl + `experiments/${uuid}`;
+
+    return this.httpService
+      .get<string>(path)
+      .pipe(map((response) => response.data));
+  }
+
+  deleteExperiment(uuid: string): Observable<string> {
+    const path = this.options.baseurl + `experiments/${uuid}`;
+
+    return this.httpService.delete(path).pipe(map((response) => response.data));
+  }
+
+  editExperiment(uuid: string, request: Request): Observable<string> {
+    const path = this.options.baseurl + `experiments/${uuid}`;
+
+    return this.httpService
+      .post(path, request.body)
+      .pipe(map((response) => response.data));
+  }
+
+  startExperimentTransient(request: Request): Observable<string> {
+    const path = this.options.baseurl + 'experiments/transient';
+
+    return this.httpService
+      .post(path, request.body)
+      .pipe(map((response) => response.data));
+  }
+
+  startExperiment(request: Request): Observable<string> {
+    const path = this.options.baseurl + 'experiments';
+
+    return this.httpService
+      .post(path, request.body)
+      .pipe(map((response) => response.data));
+  }
+
+  getExperiments(): Observable<string> {
+    const path = this.options.baseurl + 'experiments';
+
+    return this.httpService
+      .get<string>(path)
+      .pipe(map((response) => response.data));
+  }
+
+  getAlgorithms(): Observable<string> {
+    const path = this.options.baseurl + 'algorithms';
+
+    return this.httpService
+      .get<string>(path)
+      .pipe(map((response) => response.data));
+  }
\ No newline at end of file
+}

api/src/engine/engine.constants.ts

-export const ENGINE_MODULE_OPTIONS = "EngineModuleOption";
-export const ENGINE_SERVICE = "EngineService"
+export const ENGINE_MODULE_OPTIONS = 'EngineModuleOption';
+export const ENGINE_SERVICE = 'EngineService';
\ No newline at end of file

api/src/engine/engine.controller.ts

-import { Controller, Delete, Get, Inject, Param, Patch, Post, Req } from '@nestjs/common';
+import {
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  Patch,
+  Post,
+  Req,
+} from '@nestjs/common';
 import { Request } from 'express';
 import { Observable } from 'rxjs';
 import { ENGINE_SERVICE } from './engine.constants';
@@ -6,9 +15,11 @@ import { IEngineService } from './engine.interfaces';
 
 @Controller()
 export class EngineController {
-  constructor(@Inject(ENGINE_SERVICE) private readonly engineService: IEngineService) { }
+  constructor(
+    @Inject(ENGINE_SERVICE) private readonly engineService: IEngineService,
+  ) {}
 
-  @Get("/test")
+  @Get('/test')
   getTest(): string {
     return this.engineService.demo();
   }
@@ -23,27 +34,33 @@ export class EngineController {
     return this.engineService.getExperiments(request);
   }
 
-  @Get("/experiments/:uuid")
+  @Get('/experiments/:uuid')
   getExperiment(@Param('uuid') uuid: string): Observable<string> {
     return this.engineService.getExperiment(uuid);
   }
 
-  @Delete("/experiments/:uuid")
-  deleteExperiment(@Param('uuid') uuid: string, @Req() request: Request): Observable<string> {
+  @Delete('/experiments/:uuid')
+  deleteExperiment(
+    @Param('uuid') uuid: string,
+    @Req() request: Request,
+  ): Observable<string> {
     return this.engineService.deleteExperiment(uuid, request);
   }
 
-  @Patch("/experiments/:uuid")
-  editExperiment(@Param('uuid') uuid: string, @Req() request: Request): Observable<string> {
+  @Patch('/experiments/:uuid')
+  editExperiment(
+    @Param('uuid') uuid: string,
+    @Req() request: Request,
+  ): Observable<string> {
     return this.engineService.editExperiment(uuid, request);
   }
 
-  @Post("experiments/transient")
+  @Post('experiments/transient')
   startExperimentTransient(@Req() request: Request): Observable<string> {
     return this.engineService.startExperimentTransient(request);
   }
 
-  @Post("experiments")
+  @Post('experiments')
   startExperiment(@Req() request: Request): Observable<string> {
     return this.engineService.startExperiment(request);
   }

api/src/engine/engine.interfaces.ts

-import { Request } from "express";
-import { Observable } from "rxjs";
+import { Request } from 'express';
+import { Observable } from 'rxjs';
 
 export interface IEngineOptions {
-    type: string;
-    baseurl: string;
+  type: string;
+  baseurl: string;
 }
 
 export interface IEngineService {
-    demo(): string;
-
-    getAlgorithms(request: Request): Observable<string>;
-
-    getExperiments(request: Request): Observable<string>;
-
-    getExperiment(uuid: string): Observable<string>;
-  
-    deleteExperiment(uuid: string, request: Request): Observable<string>;
-  
-    editExperiment(uuid: string, request: Request): Observable<string>;
-  
-    startExperimentTransient(request: Request): Observable<string>;
-  
-    startExperiment(request: Request): Observable<string>;
-}
+  demo(): string;
+
+  getAlgorithms(request: Request): Observable<string>;
+
+  getExperiments(request: Request): Observable<string>;
+
+  getExperiment(uuid: string): Observable<string>;
+
+  deleteExperiment(uuid: string, request: Request): Observable<string>;
+
+  editExperiment(uuid: string, request: Request): Observable<string>;
+
+  startExperimentTransient(request: Request): Observable<string>;
+
+  startExperiment(request: Request): Observable<string>;
+}
\ No newline at end of file

api/src/engine/engine.module.ts

@@ -19,9 +19,9 @@ export class EngineModule {
     const engineProvider = {
       provide: ENGINE_SERVICE,
       useFactory: async (httpService: HttpService) => {
-        return await this.createEngineConnection(options, httpService)
+        return await this.createEngineConnection(options, httpService);
       },
-      inject: [HttpService]
+      inject: [HttpService],
     };
 
     return {
@@ -32,22 +32,18 @@ export class EngineModule {
           autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
         }),
       ],
-      providers: [
-        optionsProvider,
-        engineProvider,
-        EngineResolver
-      ],
-      controllers: [
-        EngineController
-      ],
+      providers: [optionsProvider, engineProvider, EngineResolver],
+      controllers: [EngineController],
       exports: [optionsProvider, engineProvider],
-    }
+    };
   }
 
-  private static async createEngineConnection(options: IEngineOptions, httpService: HttpService): Promise<IEngineService> {
-    let service = await import(`./connectors/${options.type}/main.connector`);
+  private static async createEngineConnection(
+    options: IEngineOptions,
+    httpService: HttpService,
+  ): Promise<IEngineService> {
+    const service = await import(`./connectors/${options.type}/main.connector`);
 
     return new service.default(options, httpService);
   }
-
 }

api/src/engine/engine.resolver.ts

@@ -6,19 +6,21 @@ import { Domain } from './models/domain.model';
 
 @Resolver()
 export class EngineResolver {
-    constructor(@Inject(ENGINE_SERVICE) private readonly engineService: IEngineService) { }
+  constructor(
+    @Inject(ENGINE_SERVICE) private readonly engineService: IEngineService,
+  ) {}
 
-    @Query(() => Domain)
-    async hello() {
-        let dummy: Domain = {
-            id: "test",
-            label: "test",
-            description: "test",
-            groups: [],
-            variables: [],
-            datasets: []
-        }
+  @Query(() => Domain)
+  async hello() {
+    const dummy: Domain = {
+      id: 'test',
+      label: 'test',
+      description: 'test',
+      groups: [],
+      variables: [],
+      datasets: [],
+    };
 
-        return dummy;
-    }
-}
+    return dummy;
+  }
+}
\ No newline at end of file

api/src/engine/models/category.model.ts

-import { Field, ObjectType } from "@nestjs/graphql";
+import { Field, ObjectType } from '@nestjs/graphql';
 
 @ObjectType()
 export class Category {
-    @Field()
-    id: string
+  @Field()
+  id: string;
 
-    @Field()
-    label: string;
-}
+  @Field()
+  label: string;
+}
\ No newline at end of file

api/src/engine/models/domain.model.ts

-import { Field, ObjectType } from "@nestjs/graphql";
-import { Category } from "./category.model";
-import { Group } from "./group.model";
+import { Field, ObjectType } from '@nestjs/graphql';
+import { Category } from './category.model';
+import { Group } from './group.model';
 
 @ObjectType()
 export class Domain extends Group {
-    @Field(type => [Category])
-    datasets: Category[];
-}
+  @Field((type) => [Category])
+  datasets: Category[];
+}
\ No newline at end of file

api/src/engine/models/group.model.ts

-import { Field, ObjectType } from "@nestjs/graphql";
-import { Variable } from "./variable.model";
+import { Field, ObjectType } from '@nestjs/graphql';
+import { Variable } from './variable.model';
 
 @ObjectType()
 export class Group {
-    @Field()
-    id: string;
+  @Field()
+  id: string;
 
-    @Field()
-    label: string;
+  @Field()
+  label: string;
 
-    @Field({ nullable: true })
-    description?: string;
+  @Field({ nullable: true })
+  description?: string;
 
-    @Field(type => [Group])
-    groups: Group[];
+  @Field((type) => [Group])
+  groups: Group[];
 
-    @Field(type => [Variable])
-    variables: Variable[];
-}
+  @Field((type) => [Variable])
+  variables: Variable[];
+}
\ No newline at end of file

api/src/engine/models/variable.model.ts

-import { Field, ObjectType } from "@nestjs/graphql";
-import { Category } from "./category.model";
-import { Group } from "./group.model";
+import { Field, ObjectType } from '@nestjs/graphql';
+import { Category } from './category.model';
+import { Group } from './group.model';
 
 @ObjectType()
 export class Variable {
-    @Field()
-    id: string;
+  @Field()
+  id: string;
 
-    @Field({ nullable: true })
-    label?: string;
+  @Field({ nullable: true })
+  label?: string;
 
-    @Field()
-    type: string;
+  @Field()
+  type: string;
 
-    @Field({ nullable: true })
-    description?: string;
+  @Field({ nullable: true })
+  description?: string;
 
-    @Field(type => [Category])
-    enumerations: Category[];
+  @Field((type) => [Category])
+  enumerations: Category[];
 
-    @Field(type => [Group])
-    groups: Group[];
-}
+  @Field((type) => [Group])
+  groups: Group[];
+}
\ No newline at end of file

api/src/main.ts

@@ -2,7 +2,7 @@ import { NestFactory } from '@nestjs/core';
 import { AppModule } from './main/app.module';
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule, {cors: true});
+  const app = await NestFactory.create(AppModule, { cors: true });
   await app.listen(process.env.GATEWAY_PORT);
 }
 bootstrap();

api/src/main/app.controller.ts

@@ -4,7 +4,7 @@ import { AppService } from './app.service';
 
 @Controller()
 export class AppController {
-  constructor(private readonly appService: AppService) { }
+  constructor(private readonly appService: AppService) {}
 
   @Get()
   getHello(): string {

api/src/main/app.module.ts

@@ -8,13 +8,14 @@ import { AppService } from './app.service';
   imports: [
     ConfigModule.forRoot({
       isGlobal: true,
-      envFilePath: ['.env', '.env.defaults']
+      envFilePath: ['.env', '.env.defaults'],
     }),
     EngineModule.forRootAsync({
       type: process.env.ENGINE_TYPE,
       baseurl: process.env.ENGINE_BASE_URL,
-    })],
+    }),
+  ],
   controllers: [AppController],
   providers: [AppService],
 })
-export class AppModule { }
+export class AppModule {}