Merge branch...

Merge branch '24-as-a-developer-i-want-to-use-husky-so-that-i-can-keep-my-code-clean' into 'develop'

Resolve "As a developer, I want to use husky so that I can keep my code clean"

Closes #24

See merge request sibmip/gateway!5

api/.husky/pre-commit

+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+cd api
+npm run lint

api/package-lock.json

@@ -36,6 +36,7 @@
         "eslint": "^7.30.0",
         "eslint-config-prettier": "^8.3.0",
         "eslint-plugin-prettier": "^3.4.0",
+        "husky": "^7.0.2",
         "jest": "^27.0.6",
         "prettier": "^2.3.2",
         "supertest": "^6.1.3",
@@ -5727,6 +5728,21 @@
         "node": ">=10.17.0"
       }
     },
+    "node_modules/husky": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/husky/-/husky-7.0.2.tgz",
+      "integrity": "sha512-8yKEWNX4z2YsofXAMT7KvA1g8p+GxtB1ffV8XtpAEGuXNAbCV5wdNKH+qTpw8SM9fh4aMPDR+yQuKfgnreyZlg==",
+      "dev": true,
+      "bin": {
+        "husky": "lib/bin.js"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/typicode"
+      }
+    },
     "node_modules/iconv-lite": {
       "version": "0.4.24",
       "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
@@ -14973,6 +14989,12 @@
       "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==",
       "dev": true
     },
+    "husky": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/husky/-/husky-7.0.2.tgz",
+      "integrity": "sha512-8yKEWNX4z2YsofXAMT7KvA1g8p+GxtB1ffV8XtpAEGuXNAbCV5wdNKH+qTpw8SM9fh4aMPDR+yQuKfgnreyZlg==",
+      "dev": true
+    },
     "iconv-lite": {
       "version": "0.4.24",
       "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",

api/package.json

@@ -18,7 +18,8 @@
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
-    "test:e2e": "jest --config ./test/jest-e2e.json"
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "prepare": "cd .. && husky install api/.husky"
   },
   "dependencies": {
     "@nestjs/axios": "^0.0.1",
@@ -48,6 +49,7 @@
     "eslint": "^7.30.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^3.4.0",
+    "husky": "^7.0.2",
     "jest": "^27.0.6",
     "prettier": "^2.3.2",
     "supertest": "^6.1.3",
@@ -74,4 +76,4 @@
     "coverageDirectory": "../coverage",
     "testEnvironment": "node"
   }
-}
+}
\ No newline at end of file

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 { 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(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  deleteExperiment(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  editExperiment(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  startExperimentTransient(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  startExperiment(): 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(() => [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(() => [Group])
+  groups: Group[];
 
-    @Field(type => [Variable])
-    variables: Variable[];
-}
+  @Field(() => [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(() => [Category])
+  enumerations: Category[];
 
-    @Field(type => [Group])
-    groups: Group[];
-}
+  @Field(() => [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

-import { HttpService } from '@nestjs/axios';
 import { Controller, Get } from '@nestjs/common';
 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 {}