[DEVREL-102] Handling multiple validation errors

Author: zero-bites

lib/Client.ts

@@ -1,8 +1,8 @@
 import { Configuration } from "./Configuration";
-import { Recipient } from "./Recipient";
 import * as crypto from "crypto";
 import * as request from "request";
-import { Exceptions } from './exceptions';
+import { Errors } from './errors';
+import ValidationError = Errors.ValidationError;
 
 /**
  * Private function to handle URL requests and standard responses
@@ -21,49 +21,49 @@ function sendRequest<T>(options: request.UriOptions) {
     // tslint:disable-next-line:cyclomatic-complexity
     request(options, (error: any, response: request.RequestResponse, responseBody: any) => {
       if (error) {
-        reject(new Exceptions.ServerError(String(error)));
+        reject(new Errors.ServerError(String(error)));
       } else {
         try {
           const data = JSON.parse(responseBody);
 
           if (response.statusCode === 200) {
             resolve(data as T);
-
-            return;
+          } else {
+            const validationErrors: ValidationError[] = data.errors.map((e: any) => {
+              return {
+                code: e.code,
+                field: e.field,
+                message: e.message,
+              };
+            });
+
+            switch (response.statusCode) {
+              case 400:
+                reject(new Errors.MalformedError(validationErrors));
+                break;
+              case 401:
+                reject(new Errors.AuthenticationError(validationErrors));
+                break;
+              case 403:
+                reject(new Errors.AuthorizationError(validationErrors));
+                break;
+              case 404:
+                reject(new Errors.NotFoundError(validationErrors));
+                break;
+              case 500:
+                reject(new Errors.ServerError("Server error", validationErrors));
+                break;
+              case 503:
+                reject(new Errors.DownForMaintenanceError(validationErrors));
+                break;
+              default:
+                reject(new Errors.UnexpectedError(`Unexpected HTTP_RESPONSE #${response.statusCode}`, validationErrors));
+            }
           }
 
-          const firstErr = (data.errors && Array.isArray(data.errors) && data.errors.length !== 0) ? data.errors[0] : undefined;
-          switch (response.statusCode) {
-            case 400:
-              const message = firstErr.code === "invalid_field" ? `${firstErr.message}: ${firstErr.field}` : firstErr.message;
-              reject(new Exceptions.Malformed(message || "Not Found"));
-
-              return;
-            case 401:
-              reject(new Exceptions.Authentication(firstErr.message || "Not Found"));
-
-              return;
-            case 403:
-              reject(new Exceptions.Authorization(firstErr.message || "Not Found"));
-
-              return;
-            case 404:
-              reject(new Exceptions.Authorization(firstErr.message || "Not Found"));
-
-              return;
-            case 500:
-              reject(new Exceptions.ServerError(firstErr.message || "Not Found"));
-
-              return;
-            case 503:
-              reject(new Exceptions.DownForMaintenance(firstErr.message || "Not Found"));
-
-              return;
-            default:
-              reject(new Exceptions.Unexpected(`Unexpected HTTP_RESPONSE #${response.statusCode}`));
-          }
+          return;
         } catch (err) {
-          reject(new Exceptions.Unexpected(String(err)));
+          reject(new Errors.UnexpectedError(String(err)));
         }
       }
     });

lib/errors/index.ts

@@ -0,0 +1,63 @@
+// tslint:disable:max-classes-per-file
+
+/**
+ * @module exceptions
+ */
+export module Errors {
+  export interface ValidationError {
+    code: string;
+    field: string;
+    message: string;
+  }
+
+  abstract class BaseError extends Error {
+    public validationErrors?: ValidationError[];
+
+    protected constructor(message: string, validationErrors?: ValidationError[]) {
+      super(message);
+      this.validationErrors = validationErrors;
+    }
+  }
+
+  export class DownForMaintenanceError extends BaseError {
+    public constructor(validationErrors?: ValidationError[]) {
+      super("Down for maintenance", validationErrors);
+    }
+  }
+
+  export class ServerError extends BaseError {
+    public constructor(message: string = "Server error", validationErrors?: ValidationError[]) {
+      super(message, validationErrors);
+    }
+  }
+
+  export class UnexpectedError extends BaseError {
+    public constructor(message: string, validationErrors?: ValidationError[]) {
+      super(message, validationErrors);
+    }
+  }
+
+  export class NotFoundError extends BaseError {
+    public constructor(validationErrors?: ValidationError[]) {
+      super("Not Found", validationErrors);
+    }
+  }
+
+  export class AuthenticationError extends BaseError {
+    public constructor(validationErrors?: ValidationError[]) {
+      super("Authentication failed", validationErrors);
+    }
+  }
+
+  export class AuthorizationError extends BaseError {
+    public constructor(validationErrors?: ValidationError[]) {
+      super("Authorization failed", validationErrors);
+    }
+  }
+
+  export class MalformedError extends BaseError {
+    public constructor(validationErrors?: ValidationError[]) {
+      super("Malformed request", validationErrors);
+    }
+  }
+}

lib/exceptions/index.ts

@@ -129,4 +129,22 @@ describe('Payment', () => {
         assert.strictEqual(paymentsCollection[0].constructor, Payment);
         assert.strictEqual(payment.externalId, paymentsCollection[0].externalId);
     });
+
+    it('handles multiple validation errors', async () => {
+        const nockDone = await startNockRec('payment-validation-errors.json');
+
+        try {
+            await testingApiClient.payment.create('undefined', undefined);
+        } catch (error) {
+            nockDone();
+
+            assert.strictEqual(error.validationErrors.length, 2);
+            assert.strictEqual(error.validationErrors[0].code, 'invalid_field');
+            assert.strictEqual(error.validationErrors[0].field, 'batchId');
+            assert.strictEqual(error.validationErrors[0].message, 'Value is invalid');
+            assert.strictEqual(error.validationErrors[1].code, 'invalid_field');
+            assert.strictEqual(error.validationErrors[1].field, 'recipient');
+            assert.strictEqual(error.validationErrors[1].message, 'Value is invalid');
+        }
+    });
 });

test/integration/PaymentSpec.ts

@@ -0,0 +1,67 @@
+[
+    {
+        "scope": "https://api.trolley.com:443",
+        "method": "POST",
+        "path": "/v1/batches/undefined/payments",
+        "body": {},
+        "status": 400,
+        "response": {
+            "ok": false,
+            "errors": [
+                {
+                    "code": "invalid_field",
+                    "message": "Value is invalid",
+                    "field": "batchId"
+                },
+                {
+                    "code": "invalid_field",
+                    "message": "Value is invalid",
+                    "field": "recipient"
+                }
+            ]
+        },
+        "rawHeaders": [
+            "Date",
+            "Thu, 30 Mar 2023 01:38:35 GMT",
+            "Content-Type",
+            "application/json; charset=utf-8",
+            "Content-Length",
+            "169",
+            "Connection",
+            "close",
+            "Cache-Control",
+            "no-store, no-cache",
+            "Content-Security-Policy",
+            "default-src 'self';base-uri 'self';block-all-mixed-content;font-src 'self' https: data:;frame-ancestors 'self';img-src 'self' data:;object-src 'none';script-src 'self';script-src-attr 'none';style-src 'self' https: 'unsafe-inline';upgrade-insecure-requests",
+            "X-DNS-Prefetch-Control",
+            "off",
+            "Expect-CT",
+            "max-age=0",
+            "Strict-Transport-Security",
+            "max-age=15552000; includeSubDomains",
+            "X-Download-Options",
+            "noopen",
+            "X-Content-Type-Options",
+            "nosniff",
+            "X-Permitted-Cross-Domain-Policies",
+            "none",
+            "Referrer-Policy",
+            "no-referrer",
+            "X-XSS-Protection",
+            "0",
+            "Access-Control-Allow-Origin",
+            "*",
+            "X-Rate-Limit-Limit",
+            "600",
+            "X-Rate-Limit-Remaining",
+            "599",
+            "X-Rate-Limit-Reset",
+            "1680140375",
+            "Vary",
+            "Origin",
+            "ETag",
+            "W/\"a9-yaEk6UF4nZNKcky6pKAYPn+yzQs\""
+        ],
+        "responseIsBinary": false
+    }
+]