WIP hotfix

Author: tacxou

app/src/composables/useApiFetch.ts

@@ -35,13 +35,20 @@ export function useApiFetch<P extends AllPaths<Paths>, M extends IgnoreCase<keyo
   body?: Paths[`/${P}`][Lowercase<M>]['requestBody']['content']['application/json'],
 ): /* @ts-ignore */
   AsyncData<OpenApiResponse<Paths[`/${P}`][Lowercase<M>]> | undefined, FetchError<OpenApiError<Paths[`/${P}`][Lowercase<M>]>>> {
+  if (!body) {
+    return useApiData(path, {
+      ...opts,
+      cache: false,
+      client: true,
+    } as any)
+  }
   return useApiData(path, {
     ...opts,
     cache: false,
     client: true,
     body: {
       ...opts?.body,
       ...body,
-    }
+    },
   } as any)
 }

app/src/pages/index.vue

@@ -9,4 +9,6 @@ div
 
 <script lang='ts' setup>
 const { signIn, signOut, session, status, cookies, getProviders, user, sessionToken } = useAuth()
+
+const test = useApiFetch('tickets/sla')
 </script>

service/package.json

@@ -46,6 +46,7 @@
     "types-package-json": "^2.0.39"
   },
   "devDependencies": {
+    "@jest-mock/express": "^2.0.2",
     "@kradihsoy/lt-schematics": "*",
     "@nestjs/cli": "^9.0.0",
     "@nestjs/schematics": "^9.0.0",

service/src/_common/dto/parts/entity.part.dto.ts

@@ -1,10 +1,10 @@
-import { IsEnum, IsString } from 'class-validator'
+import { IsEnum, IsNumber, IsString } from 'class-validator'
 import { ApiProperty } from '@nestjs/swagger'
 import { IdnamePartDto } from '~/_common/dto/parts/idname.part.dto'
 import { EntityType, EntityTypeList } from '~/_common/enum/entity-type.enum'
 
 export class EntityPartDto extends IdnamePartDto {
-  @IsString()
+  @IsNumber()
   @IsEnum(EntityTypeList)
   @ApiProperty({ enum: EntityTypeList })
   public type: EntityType

service/src/_common/filters/mongoose-validation.filter.ts

@@ -1,28 +1,29 @@
 import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus, Logger } from '@nestjs/common'
-import { Response } from 'express'
+import { Request, Response } from 'express'
 import { Error } from 'mongoose'
 import { ValidationError } from 'class-validator'
 
 @Catch(Error.ValidationError, Error.CastError, ValidationError)
 export class MongooseValidationFilter implements ExceptionFilter {
   public catch(exception: Error.ValidationError | Error.CastError | ValidationError, host: ArgumentsHost) {
     const ctx = host.switchToHttp()
+    const request = ctx.getRequest<Request>()
     const response = ctx.getResponse<Response>()
     Logger.debug(exception['message'], 'MongooseValidationFilter')
     let debug = {}
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== 'production' && request.query['debug']) {
       debug['_exception'] = exception
     }
-    response.status(HttpStatus.BAD_REQUEST).json(
+    response.status(HttpStatus.NOT_ACCEPTABLE).json(
       HttpException.createBody(
         {
-          statusCode: HttpStatus.BAD_REQUEST,
+          statusCode: HttpStatus.NOT_ACCEPTABLE,
           message: exception['message'],
           validations: this.getValidationErrors(exception),
           ...debug,
         },
         exception.constructor.name,
-        HttpStatus.BAD_REQUEST,
+        HttpStatus.NOT_ACCEPTABLE,
       ),
     )
   }

service/src/_common/helpers/pick-projection.helper.ts

@@ -1,17 +1,12 @@
 import { Type } from '@nestjs/common'
-import { PickType } from '@nestjs/swagger'
 
+// noinspection JSUnusedLocalSymbols
 export function PickProjectionHelper<T, K extends keyof T>(
   classRef: Type<T>,
-  // classRef: any,
-  projection: {
+  _projection: {
     [key in keyof T]?: number | 1 | 0
   },
-): Type<Pick<T, any>> {
-// ): Type<Pick<T, (readonly K[])[number]>> {
-  const keys = Object.keys(projection)
-    // .filter((key) => projection[key] === 1)
-  return PickType(classRef, keys as K[])
+): Type<T> {
+  //TODO: fix to use projection with pick or partial
+  return classRef
 }
-
-// console.log(PickProjectionHelper({ a: number, b: 2, c: 3 }, { a: 1, b: 1 }))

service/src/_common/pipes/dto-validation.pipe.ts

@@ -1,39 +1,63 @@
-import { BadRequestException, HttpStatus, ValidationPipe, ValidationError, Logger } from '@nestjs/common'
+import {
+  BadRequestException,
+  HttpStatus,
+  ValidationPipe,
+  ValidationError,
+  Logger,
+  Injectable,
+  Scope, Inject,
+} from '@nestjs/common'
+import { REQUEST } from '@nestjs/core'
+import { Request } from 'express'
 
+interface ValidationRecursive {
+  [key: string]: string
+}
+
+@Injectable({ scope: Scope.REQUEST })
 export class DtoValidationPipe extends ValidationPipe {
-  public constructor() {
+  public constructor(@Inject(REQUEST) protected readonly request: Request) {
     super({
       transform: true,
-      exceptionFactory: (errors) => {
-        const validations = {}
-        const errorsMessage = []
-        errors.forEach((error: ValidationError) => {
-          if (error.constraints) {
-            Object.values(error.constraints).forEach((value) => {
-              validations[error.property] = value
-              errorsMessage.push(`${error.property}: ${value}`)
-            })
-          }
-          if (error.children.length > 0) {
-            validations[error.property] = {}
-            error.children.forEach((childError: ValidationError) => {
-              if (childError.constraints) {
-                Object.values(childError.constraints).forEach((value) => {
-                  validations[error.property][childError.property] = value
-                  errorsMessage.push(`${error.property}.${childError.property}: ${value}`)
-                })
-              }
-            })
-          }
-        })
-        const message = `Validation failed: ${errorsMessage.join(', ')}`
-        Logger.debug(message, 'DtoValidationPipe')
+      transformOptions: {
+        enableImplicitConversion: true,
+      },
+      exceptionFactory: (errors: ValidationError[]) => {
+        let validations: ValidationRecursive = {}
+        for (const error of errors) {
+          validations = { ...validations, ...this.validationRecursive(error)}
+        }
+        const debug = {}
+        const message = `Erreur de validation : ${Object.keys(validations).join(', ')}`.trim()
+        Logger.debug(`${message} (${JSON.stringify(validations)})`, 'DtoValidationPipe')
+        if (process.env.NODE_ENV !== 'production' && request.query['debug']) {
+          debug['_errors'] = errors
+        }
         return new BadRequestException({
           statusCode: HttpStatus.BAD_REQUEST,
           message,
           validations,
+          ...debug,
         })
       },
     })
   }
+
+  public validationRecursive(error: ValidationError, prefix = ''): ValidationRecursive {
+    let validations = {}
+    if (error.constraints) {
+      validations[`${prefix + error.property}`] = Object.values(error.constraints)[0]
+    }
+    if (error.children.length > 0) {
+      for (const errorChild of error.children) {
+        if (errorChild.constraints) {
+          validations[`${prefix + errorChild.property}`] = Object.values(errorChild.constraints)[0]
+        }
+        if (errorChild.children.length > 0) {
+          validations = { ...validations, ...this.validationRecursive(errorChild, `${prefix + error.property}.${errorChild.property}.`) }
+        }
+      }
+    }
+    return validations
+  }
 }