#RI-3902 rework errors to return

Author: Artem

redisinsight/api/src/__mocks__/database-import.ts

@@ -24,7 +24,7 @@ export const mockDatabaseImportResultFail = {
   status: DatabaseImportStatus.Fail,
   host: mockDatabase.host,
   port: mockDatabase.port,
-  error: new BadRequestException(),
+  errors: [new BadRequestException()],
 };
 
 export const mockDatabaseImportResponse = Object.assign(new DatabaseImportResponse(), {
@@ -34,10 +34,14 @@ export const mockDatabaseImportResponse = Object.assign(new DatabaseImportRespon
     index: index + 3,
   })),
   partial: [],
-  fail: [new ValidationException([]), new BadRequestException(), new ForbiddenException()].map((error, index) => ({
+  fail: [
+    new ValidationException('Bad request'),
+    new BadRequestException(),
+    new ForbiddenException(),
+  ].map((error, index) => ({
     ...mockDatabaseImportResultFail,
     index,
-    error,
+    errors: [error],
   })),
 });
 

redisinsight/api/src/modules/database-import/database-import.analytics.ts

@@ -1,8 +1,9 @@
+import { uniq } from 'lodash';
 import { Injectable } from '@nestjs/common';
 import { TelemetryBaseService } from 'src/modules/analytics/telemetry.base.service';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import { TelemetryEvents } from 'src/constants';
-import { DatabaseImportResponse } from 'src/modules/database-import/dto/database-import.response';
+import { DatabaseImportResponse, DatabaseImportResult } from 'src/modules/database-import/dto/database-import.response';
 
 @Injectable()
 export class DatabaseImportAnalytics extends TelemetryBaseService {
@@ -25,7 +26,7 @@ export class DatabaseImportAnalytics extends TelemetryBaseService {
         TelemetryEvents.DatabaseImportFailed,
         {
           failed: importResult.fail.length,
-          errors: importResult.fail.map((res) => (res?.error?.constructor?.name || 'UncaughtError')),
+          errors: DatabaseImportAnalytics.getUniqueErrorNamesFromResults(importResult.fail),
         },
       );
     }
@@ -35,7 +36,7 @@ export class DatabaseImportAnalytics extends TelemetryBaseService {
         TelemetryEvents.DatabaseImportPartiallySucceeded,
         {
           partially: importResult.partial.length,
-          errors: importResult.partial.map((res) => (res?.error?.constructor?.name || 'UncaughtError')),
+          errors: DatabaseImportAnalytics.getUniqueErrorNamesFromResults(importResult.partial),
         },
       );
     }
@@ -49,4 +50,16 @@ export class DatabaseImportAnalytics extends TelemetryBaseService {
       },
     );
   }
+
+  static getUniqueErrorNamesFromResults(results: DatabaseImportResult[]) {
+    return uniq(
+      [].concat(
+        ...results.map(
+          (res) => (res?.errors || []).map(
+            (error) => error?.constructor?.name || 'UncaughtError',
+          ),
+        ),
+      ),
+    );
+  }
 }

redisinsight/api/src/modules/database-import/database-import.service.spec.ts

@@ -59,10 +59,7 @@ describe('DatabaseImportService', () => {
     it('should import databases from json', async () => {
       const response = await service.import(mockDatabaseImportFile);
 
-      expect(response).toEqual({
-        ...mockDatabaseImportResponse,
-        errors: undefined, // errors omitted from response
-      });
+      expect(response).toEqual(mockDatabaseImportResponse);
       expect(analytics.sendImportResults).toHaveBeenCalledWith(mockDatabaseImportResponse);
     });
 
@@ -75,7 +72,6 @@ describe('DatabaseImportService', () => {
 
       expect(response).toEqual({
         ...mockDatabaseImportResponse,
-        errors: undefined, // errors omitted from response
       });
       expect(analytics.sendImportResults).toHaveBeenCalledWith(mockDatabaseImportResponse);
     });

redisinsight/api/src/modules/database-import/database-import.service.ts

@@ -1,4 +1,6 @@
-import { HttpException, Injectable, InternalServerErrorException, Logger } from '@nestjs/common';
+import {
+  HttpException, Injectable, InternalServerErrorException, Logger,
+} from '@nestjs/common';
 import { get, isArray, set } from 'lodash';
 import { Database } from 'src/modules/database/models/database';
 import { plainToClass } from 'class-transformer';
@@ -163,27 +165,32 @@ export class DatabaseImportService {
         port: database.port,
       };
     } catch (e) {
-      let error = e;
+      let errors = [e];
       if (isArray(e)) {
-        [error] = e;
+        errors = e;
       }
 
-      if (error instanceof ValidationError) {
-        error = new ValidationException(Object.values(error?.constraints || {}) || 'Bad request');
-      }
+      errors = errors.map((error) => {
+        if (error instanceof ValidationError) {
+          const messages = Object.values(error?.constraints || {});
+          return new ValidationException(messages[messages.length - 1] || 'Bad request');
+        }
 
-      if (!(error instanceof HttpException)) {
-        error = new InternalServerErrorException(error?.message);
-      }
+        if (!(error instanceof HttpException)) {
+          return new InternalServerErrorException(error?.message);
+        }
+
+        return error;
+      });
 
-      this.logger.warn(`Unable to import database: ${error?.constructor?.name || 'UncaughtError'}`, error);
+      this.logger.warn(`Unable to import database: ${errors[0]?.constructor?.name || 'UncaughtError'}`, errors[0]);
 
       return {
         index,
         status: DatabaseImportStatus.Fail,
         host: item?.host,
         port: item?.port,
-        error,
+        errors,
       };
     }
   }

redisinsight/api/src/modules/database-import/dto/database-import.response.ts

@@ -1,4 +1,4 @@
-import { isArray, isString, isNumber } from 'lodash';
+import { isString, isNumber } from 'lodash';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Expose, Transform, Type } from 'class-transformer';
 
@@ -49,13 +49,19 @@ export class DatabaseImportResult {
       return undefined;
     }
 
-    if (e?.response?.message) {
-      return isArray(e.response.message) ? e.response.message[e.response.message.length - 1] : e.response.message;
-    }
+    return e.map((error) => {
+      if (error?.response) {
+        return error.response;
+      }
 
-    return e?.message || 'Unhandled Error';
+      return {
+        statusCode: 500,
+        message: error?.message || 'Unhandled Error',
+        error: 'Unhandled Error',
+      };
+    });
   }, { toPlainOnly: true })
-  error?: Error;
+  errors?: Error[];
 }
 
 export class DatabaseImportResponse {

redisinsight/api/test/api/database-import/POST-databases-import.test.ts

@@ -73,7 +73,10 @@ describe('POST /databases/import', () => {
             expect(body.fail.length).to.eq(1);
             expect(body.fail[0].status).to.eq('fail');
             expect(body.fail[0].index).to.eq(0);
-            expect(body.fail[0].error).to.be.a('string');
+            expect(body.fail[0].errors.length).to.eq(1);
+            expect(body.fail[0].errors[0].message).to.be.a('string');
+            expect(body.fail[0].errors[0].statusCode).to.eq(400);
+            expect(body.fail[0].errors[0].error).to.eq('Bad Request');
             if (body.fail[0].host) {
               expect(body.fail[0].host).to.be.a('string');
             }