Added field HttpError.data containing full JSON response

Author: bastianeicher

endpoints/Endpoint.test.ts

@@ -242,7 +242,7 @@ test('errorHandlingWithNoContent', async () => {
 
 test('errorHandlingWithMessage', async () => {
     fetchMock.mockOnceIf('http://localhost/endpoint',
-        '{"message":"my message"}',
+        '{"message":"my message","extra":"info"}',
         {
             status: HttpStatusCode.Conflict,
             headers: {
@@ -254,7 +254,9 @@ test('errorHandlingWithMessage', async () => {
     try {
         await endpoint.get();
     } catch (err) {
-        errorThrown = err instanceof ConflictError && err.message === 'my message';
+        errorThrown = err instanceof ConflictError
+            && err.message === 'my message'
+            && err.data.extra === 'info';
     }
     expect(errorThrown).toBe(true);
 });

errors/DefaultErrorHandler.ts

@@ -1,4 +1,4 @@
-import { ErrorHandler, HttpError, BadRequestError, AuthenticationError, AuthorizationError, NotFoundError, TimeoutError, ConflictError, ConcurrencyError, RangeError } from ".";
+import { ErrorHandler, HttpError, BadRequestError, AuthenticationError, AuthorizationError, NotFoundError, TimeoutError, ConflictError, ConcurrencyError } from ".";
 import { HttpStatusCode, HttpHeader } from "../http";
 
 /**
@@ -15,46 +15,42 @@ export class DefaultErrorHandler implements ErrorHandler {
      * @throws {@link TimeoutError}: {@link HttpStatusCode.RequestTimeout}
      * @throws {@link ConflictError}: {@link HttpStatusCode.Conflict}
      * @throws {@link ConcurrencyError}: {@link HttpStatusCode.PreconditionFailed}
-     * @throws {@link RangeError}: {@link HttpStatusCode.RequestedRangeNotSatisfiable}
      * @throws {@link HttpError}: Other non-success status code
      */
     async handle(response: Response) {
         if (response.ok) return;
 
-        const message = await this.extractJsonMessage(response);
-        throw DefaultErrorHandler.mapToError(
-            response.status,
-            message ?? `HTTP ${response.status} ${response.statusText}`);
-    }
-
-    private async extractJsonMessage(response: Response) {
         const contentType = response.headers.get(HttpHeader.ContentType);
-        return (contentType?.startsWith("application/json") || contentType?.includes("+json"))
-            ? (await response.json())?.message
+        const jsonBody = (contentType?.startsWith("application/json") || contentType?.includes("+json"))
+            ? await response.json()
             : undefined;
+
+        const errorType = DefaultErrorHandler.errorType(response.status);
+        throw new errorType(
+            jsonBody?.message ?? jsonBody?.details ?? `HTTP ${response.status} ${response.statusText}`,
+            response.status,
+            jsonBody);
     }
 
-    private static mapToError(status: HttpStatusCode, message: string) {
+    private static errorType(status: HttpStatusCode): new (message: string, status: HttpStatusCode, data?: any) => Error {
         switch (status) {
             case HttpStatusCode.BadRequest:
-                return new BadRequestError(message, status)
+                return BadRequestError;
             case HttpStatusCode.Unauthorized:
-                return new AuthenticationError(message, status)
+                return AuthenticationError;
             case HttpStatusCode.Forbidden:
-                return new AuthorizationError(message, status)
+                return AuthorizationError;
             case HttpStatusCode.NotFound:
             case HttpStatusCode.Gone:
-                return new NotFoundError(message, status)
+                return NotFoundError;
             case HttpStatusCode.RequestTimeout:
-                return new TimeoutError(message, status)
+                return TimeoutError;
             case HttpStatusCode.Conflict:
-                return new ConflictError(message, status)
+                return ConflictError;
             case HttpStatusCode.PreconditionFailed:
-                return new ConcurrencyError(message, status)
-            case HttpStatusCode.RequestedRangeNotSatisfiable:
-                return new RangeError(message, status)
+                return ConcurrencyError;
             default:
-                return new HttpError(message, status);
+                return HttpError;
         }
     }
 }

errors/Errors.ts

@@ -2,56 +2,52 @@ import { HttpStatusCode } from "../http";
 
 /* tslint:disable:max-classes-per-file */
 
+/**
+ * Thrown on HTTP response with a non-successful status code (4xx or 5xx).
+ */
 export class HttpError extends Error {
-    constructor(message: string, public status: HttpStatusCode) {
+    /**
+     * Creates a new HTTP error.
+     * @param message The error message.
+     * @param status The HTTP status code.
+     * @param data Additional error data.
+     */
+    constructor(message: string, public status: HttpStatusCode, public data?: any) {
         super(message);
     }
 }
 
-export class BadRequestError extends HttpError {
-    constructor(message: string, status = HttpStatusCode.BadRequest) {
-        super(message, status);
-    }
-}
+/**
+ * Thrown on HTTP response for a bad request (usually {@link HttpStatusCode.BadRequest}).
+ */
+export class BadRequestError extends HttpError {}
 
-export class AuthenticationError extends HttpError {
-    constructor(message: string, status = HttpStatusCode.Unauthorized) {
-        super(message, status);
-    }
-}
+/**
+ * Thrown on HTTP response for an unauthenticated request, i.e. missing credentials (usually {@link HttpStatusCode.Unauthorized}).
+ */
+export class AuthenticationError extends HttpError {}
 
-export class AuthorizationError extends HttpError {
-    constructor(message: string, status = HttpStatusCode.Forbidden) {
-        super(message, status);
-    }
-}
+/**
+ * Thrown on HTTP response for an unauthorized request, i.e. missing permissions (usually {@link HttpStatusCode.Forbidden}).
+ */
+export class AuthorizationError extends HttpError {}
 
-export class NotFoundError extends HttpError {
-    constructor(message: string, status = HttpStatusCode.NotFound) {
-        super(message, status);
-    }
-}
+/**
+ * Thrown on HTTP response for a missing resource (usually {@link HttpStatusCode.NotFound} or {@link HttpStatusCode.Gone}).
+ */
+export class NotFoundError extends HttpError {}
 
-export class TimeoutError extends HttpError {
-    constructor(message: string, status = HttpStatusCode.RequestTimeout) {
-        super(message, status);
-    }
-}
-
-export class ConflictError extends HttpError {
-    constructor(message: string, status = HttpStatusCode.Conflict) {
-        super(message, status);
-    }
-}
+/**
+ * Thrown on HTTP response for a timed-out operation (usually {@link HttpStatusCode.Timeout}).
+ */
+export class TimeoutError extends HttpError {}
 
-export class ConcurrencyError extends HttpError {
-    constructor(message: string, status = HttpStatusCode.PreconditionFailed) {
-        super(message, status);
-    }
-}
+/**
+ * Thrown on HTTP response for a resource conflict (usually {@link HttpStatusCode.Conflict}).
+ */
+export class ConflictError extends HttpError {}
 
-export class RangeError extends HttpError {
-    constructor(message: string, status = HttpStatusCode.RequestedRangeNotSatisfiable) {
-        super(message, status);
-    }
-}
+/**
+ * Thrown on HTTP response for a failed precondition or mid-air collision (usually {@link HttpStatusCode.PreconditionFailed}).
+ */
+export class ConcurrencyError extends HttpError {}

http/HttpStatusCode.ts

@@ -10,6 +10,5 @@ export enum HttpStatusCode {
     RequestTimeout = 408,
     Conflict = 409,
     Gone = 410,
-    PreconditionFailed = 412,
-    RequestedRangeNotSatisfiable = 416
+    PreconditionFailed = 412
 }