Refactor code and fix validation errors

Author: RICHARD-Quentin

src/_common/errors/BadConfig.ts

@@ -0,0 +1,13 @@
+import { HttpException } from '@nestjs/common';
+
+export class ValidationException extends HttpException {
+  constructor(message, statusCode = 400) {
+    super(message, statusCode);
+    this.name = this.constructor.name;
+    this.getStatus = () => statusCode;
+  }
+}
+
+export class ValidationSchemaException extends ValidationException {}
+
+export class ValidationConfigException extends ValidationException {}

src/_common/errors/ValidationException.ts

@@ -7,6 +7,7 @@ import { utilities as nestWinstonModuleUtilities, WinstonModule } from 'nest-win
 import { createLogger } from 'winston';
 import * as winston from 'winston';
 import 'winston-mongodb';
+import { appendFile } from 'fs';
 
 declare const module: any;
 (async (): Promise<void> => {
@@ -59,6 +60,7 @@ declare const module: any;
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     (await import('./swagger')).default(app);
   }
+
   await app.listen(3000, async (): Promise<void> => {
     Logger.log(`Application is running on port: ${process.env.PORT || 3000}`);
   });

src/main.ts

@@ -1,4 +1,15 @@
-import { Body, Controller, Delete, Get, HttpStatus, Param, Patch, Post, Res } from '@nestjs/common';
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpStatus,
+  Param,
+  Patch,
+  Post,
+  Res,
+} from '@nestjs/common';
 import { IdentitiesDto, IdentitiesCreateDto, IdentitiesUpdateDto } from './_dto/identities.dto';
 import { IdentitiesService } from './identities.service';
 import { AbstractController } from '~/_common/abstracts/abstract.controller';
@@ -18,6 +29,8 @@ import { IdentitiesValidationService } from './validations/identities.validation
 import { MixedValue } from '~/_common/types/mixed-value.type';
 import { Identities } from './_schemas/identities.schema';
 import { Document } from 'mongoose';
+import { ValidationConfigException, ValidationSchemaException } from '~/_common/errors/ValidationException';
+import { IdentityState } from './_enums/states.enum';
 
 @ApiTags('management')
 @Controller('identities')
@@ -52,16 +65,26 @@ export class IdentitiesController extends AbstractController {
     >
   > {
     try {
+      let statusCode = HttpStatus.CREATED;
+      let message = null;
       const data = await this._service.create<Identities>(body);
-      return res.status(HttpStatus.CREATED).json({
-        statusCode: HttpStatus.CREATED,
+      if (data.state === IdentityState.TO_COMPLETE) {
+        statusCode = HttpStatus.ACCEPTED;
+        message = 'Identitée créée avec succès, mais des champs additionnels sont manquants ou invalides.';
+      }
+      return res.status(statusCode).json({
+        statusCode,
         data,
+        message,
       });
     } catch (error) {
+      let validations = error.validations;
+      if (error instanceof ValidationSchemaException || error instanceof ValidationConfigException)
+        validations = error.getResponse().response;
       return res.status(HttpStatus.BAD_REQUEST).json({
         statusCode: HttpStatus.BAD_REQUEST,
         message: error.message,
-        validations: error.validations,
+        validations: validations,
       });
     }
   }
@@ -107,10 +130,12 @@ export class IdentitiesController extends AbstractController {
         data,
       });
     } catch (error) {
+      let validations = error.validations;
+      if (error instanceof BadRequestException) validations = error.getResponse();
       return res.status(HttpStatus.BAD_REQUEST).json({
         statusCode: HttpStatus.BAD_REQUEST,
         message: error.message,
-        validations: error.validations,
+        validations: validations,
       });
     }
   }

src/management/identities/identities.controller.ts

@@ -6,6 +6,7 @@ import { IdentitiesController } from './identities.controller';
 import { IdentitiesValidationService } from './validations/identities.validation.service';
 import { IdentitiesValidationModule } from './validations/identities.validation.module';
 import { IdentityState } from './_enums/states.enum';
+import { ValidationConfigException, ValidationSchemaException } from '~/_common/errors/ValidationException';
 
 @Module({
   imports: [
@@ -21,26 +22,39 @@ import { IdentityState } from './_enums/states.enum';
           // If the validation fails and the state is TO_CREATE, the state is set to TO_COMPLETE
           // Else the error is thrown
           schema.pre('validate', async function (next) {
+            const commonLogMessage = `additionalFields error for ${this.inetOrgPerson.cn}  `;
             try {
               Logger.log(`additionalFields validation start for ${this.inetOrgPerson.cn}  `);
+
               await validationService.validate(this.additionalFields);
+
               Logger.log(`additionalFields validation end for ${this.inetOrgPerson.cn}  `);
             } catch (error) {
-              Logger.error(`additionalFields validation error for ${this.inetOrgPerson.cn}  `, error);
-              if (error instanceof BadRequestException) {
-                Logger.error(`additionalFields validation error for ${this.inetOrgPerson.cn}  `, error.getResponse());
-                throw new Error(error.getResponse().toString());
+              // If the error is a ValidationConfigException, we throw it
+              if (error instanceof ValidationConfigException) {
+                Logger.error(commonLogMessage, error.getResponse());
+                throw new ValidationConfigException(error);
+              }
+
+              // If the error is a ValidationSchemaException and the state is TO_CREATE, we set it to TO_COMPLETE
+              // Else we throw it
+              if (error instanceof ValidationSchemaException) {
+                Logger.error(commonLogMessage, error.getResponse());
+                if (this.state === IdentityState.TO_CREATE) {
+                  Logger.warn(commonLogMessage, 'Setting state to TO_COMPLETE');
+                  this.state = IdentityState.TO_COMPLETE;
+                } else throw new ValidationSchemaException(error);
+              } else {
+                Logger.error(commonLogMessage, error);
+                throw new Error(error);
               }
-              if (this.state === IdentityState.TO_CREATE) this.state = IdentityState.TO_COMPLETE;
-              else throw new Error(error);
             }
             next();
           });
 
           // Pre save hook
           // This hook is used to set the state to TO_SYNC if the state is TO_CREATE
           schema.pre('save', async function (next) {
-            console.log('pre save');
             if (this.state === IdentityState.TO_CREATE) this.state = IdentityState.TO_VALIDATE;
             next();
           });

src/management/identities/identities.module.ts

@@ -2,10 +2,8 @@ $schema: "http://json-schema.org/draft-07/schema#"
 type: "object"
 properties:
   supannEmpId:
-    type: "array"
+    type: "string"
     description: "Employee ID"
-    items:
-      type: "string"
   supannCivilite:
     type: "string"
     description: "Title (Mr, Ms, etc.)"

src/management/identities/validations/_config/supann.yml

@@ -19,7 +19,7 @@ const validSchema = {
           properties: {
             type: {
               type: 'string',
-              const: 'string',
+              enum: ['string', 'number', 'boolean', 'array', 'object', 'date'],
               errorMessage: "Chaque propriété doit avoir un 'type' de 'string'.",
             },
             description: {

src/management/identities/validations/_config/validSchema.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { parse } from 'yaml';
 import { existsSync, readFileSync } from 'fs';
 import { ConfigObjectSchemaDTO } from './_dto/config.dto';
@@ -9,7 +9,7 @@ import Ajv from 'ajv';
 import { buildYup } from 'schema-to-yup';
 import ajvErrors from 'ajv-errors';
 import validSchema from './_config/validSchema';
-import { BadConfig } from '~/_common/errors/BadConfig';
+import { ValidationConfigException, ValidationSchemaException } from '~/_common/errors/ValidationException';
 
 /**
  * Service responsible for validating identities.
@@ -18,10 +18,12 @@ import { BadConfig } from '~/_common/errors/BadConfig';
 export class IdentitiesValidationService {
   private ajv: Ajv = new Ajv({ allErrors: true });
   private validateSchema;
+  private logger: Logger;
 
   constructor() {
     ajvErrors(this.ajv);
     this.validateSchema = this.ajv.compile(validSchema);
+    this.logger = new Logger();
   }
 
   /**
@@ -38,21 +40,23 @@ export class IdentitiesValidationService {
 
     // Check for missing attributes
     for (const attribute of diff(objectClasses, attributesKeys)) {
-      validations[attribute] = `Missing attribute '${attribute}'`;
+      validations[attribute] = `Attribut '${attribute}' manquant dans les champs additionnels`;
       reject = true;
     }
 
     for (const key of attributesKeys) {
       if (!objectClasses.includes(key)) {
         validations[key] =
-          `${key} is not a valid object class in this context, valid object classes are: ${objectClasses.join(', ')}'`;
+          `${key} n'est pas une classe d'objet valide dans ce contexte, les classes d'objets valides sont: ${objectClasses.join(
+            ', ',
+          )}'`;
         reject = true;
         continue;
       }
 
       const path = `./src/management/identities/validations/_config/${key}.yml`;
       if (!existsSync(path)) {
-        validations[key] = `Config '${key}.yml' not found`;
+        validations[key] = `Fichier de config '${key}.yml' introuvable`;
         reject = true;
         continue;
       }
@@ -66,7 +70,7 @@ export class IdentitiesValidationService {
     }
 
     if (reject) {
-      throw new BadRequestException(validations);
+      throw new ValidationConfigException(validations);
     }
 
     // Validate each attribute
@@ -79,10 +83,7 @@ export class IdentitiesValidationService {
     }
 
     if (reject) {
-      return Promise.reject({
-        message: 'Validation failed',
-        validations: construct(validations),
-      });
+      throw new ValidationSchemaException(validations);
     }
     return Promise.resolve({ message: 'Validation succeeded' });
   }
@@ -102,7 +103,10 @@ export class IdentitiesValidationService {
       await yupSchema.validate(attribute, { strict: true, abortEarly: false });
       return null;
     } catch (error) {
-      return error.inner.map((err) => `${key}.${err.path}: ${err.errors[0]}`).join(', ');
+      return error.inner.reduce((acc, err) => {
+        acc[err.path] = err.message;
+        return acc;
+      }, {});
     }
   }
 }