@tstdl/base 0.90.5 → 0.90.6

package/errors/errors.localization.js

@@ -1,6 +1,6 @@
 import { HttpErrorReason } from '../http/http.error.js';
 import { enumerationLocalization, getLocalizationKeys } from '../text/localization.service.js';
-import { isDefined } from '../utils/type-guards.js';
+import { isDefined, isNotNull } from '../utils/type-guards.js';
 export const errorsLocalizationKeys = getLocalizationKeys();
 export const germanTstdlErrorsLocalization = {
     language: { code: 'de', name: 'Deutsch' },
@@ -58,7 +58,7 @@ export const germanTstdlErrorsLocalization = {
                 header: (error) => ((isDefined(error.response) && error.response.statusCode != 0)
                     ? `Http Fehler - ${error.response.statusCode.toString()}`
                     : 'Http Fehler'),
-                message: (error, context) => context.localizationService.localizeOnce({ enum: HttpErrorReason, value: error.reason })
+                message: getHttpErrorMessage
             },
             SecretRequirementsError: {
                 header: 'Passwortanforderungen nicht erfüllt',
@@ -70,8 +70,9 @@ export const germanTstdlErrorsLocalization = {
         enumerationLocalization(HttpErrorReason, {
             [HttpErrorReason.Unknown]: 'Unbekannt',
             [HttpErrorReason.Cancelled]: 'Anfrage abgebrochen',
+            [HttpErrorReason.Network]: 'Netzwerkfehler',
             [HttpErrorReason.InvalidRequest]: 'Ungültige Anfrage',
-            [HttpErrorReason.Non200StatusCode]: 'Antwort enthielt einen Fehler',
+            [HttpErrorReason.StatusCode]: 'Antwort enthielt einen Fehler',
             [HttpErrorReason.ErrorResponse]: 'Antwort enthielt einen Fehler',
             [HttpErrorReason.ResponseError]: 'Fehler beim Empfang der Antwort',
             [HttpErrorReason.Timeout]: 'Zeitüberschreitung'
@@ -134,7 +135,7 @@ export const englishTstdlErrorsLocalization = {
                 header: (error) => ((isDefined(error.response) && error.response.statusCode != 0)
                     ? `Http error - ${error.response.statusCode.toString()}`
                     : 'Http error'),
-                message: (error, context) => context.localizationService.localizeOnce({ enum: HttpErrorReason, value: error.reason })
+                message: getHttpErrorMessage
             },
             SecretRequirementsError: {
                 header: 'Secret requirements not met',
@@ -146,14 +147,20 @@ export const englishTstdlErrorsLocalization = {
         enumerationLocalization(HttpErrorReason, {
             [HttpErrorReason.Unknown]: 'Unknown',
             [HttpErrorReason.Cancelled]: 'Request cancelled',
+            [HttpErrorReason.Network]: 'Network error',
             [HttpErrorReason.InvalidRequest]: 'Invalid request',
-            [HttpErrorReason.Non200StatusCode]: 'Response contained an error',
+            [HttpErrorReason.StatusCode]: 'Response contained an error',
             [HttpErrorReason.ErrorResponse]: 'Response contained an error',
             [HttpErrorReason.ResponseError]: 'Error while receiving the response',
             [HttpErrorReason.Timeout]: 'Zeitüberschreitung'
         })
     ]
 };
+function getHttpErrorMessage(error, context) {
+    return (isDefined(error.response) && (isNotNull(error.response.statusMessage)))
+        ? error.response.statusMessage
+        : context.localizationService.localizeOnce({ enum: HttpErrorReason, value: error.reason });
+}
 function getErrorMessage(error) {
     return error.message.replace(/\.$/u, '');
 }

package/http/client/adapters/undici.adapter.js

@@ -66,9 +66,7 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
         }
         catch (error) {
             if (error instanceof undiciErrors.UndiciError) {
-                const reason = ((error instanceof undiciErrors.BodyTimeoutError) || (error instanceof undiciErrors.HeadersTimeoutError)) ? HttpErrorReason.Timeout
-                    : (error instanceof undiciErrors.RequestAbortedError) ? HttpErrorReason.Cancelled
-                        : HttpErrorReason.Unknown;
+                const reason = getHttpErrorReason(error);
                 throw new HttpError(reason, httpClientRequest, undefined, undefined, error);
             }
             throw error;
@@ -88,3 +86,32 @@ export function configureUndiciHttpClientAdapter(options = {}) {
         Injector.register(HttpClientAdapter, { useToken: UndiciHttpClientAdapter });
     }
 }
+function getHttpErrorReason(error) {
+    switch (error.code) {
+        case 'UND_ERR_CONNECT_TIMEOUT':
+        case 'UND_ERR_HEADERS_TIMEOUT':
+        case 'UND_ERR_BODY_TIMEOUT':
+            return HttpErrorReason.Timeout;
+        case 'UND_ERR_RESPONSE_STATUS_CODE':
+            return HttpErrorReason.StatusCode;
+        case 'UND_ERR_HEADERS_OVERFLOW':
+        case 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH':
+            return HttpErrorReason.ResponseError;
+        case 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH':
+        case 'UND_ERR_INVALID_ARG':
+        case 'UND_ERR_INVALID_RETURN_VALUE':
+            return HttpErrorReason.InvalidRequest;
+        case 'UND_ERR_ABORTED':
+        case 'UND_ERR_DESTROYED':
+        case 'UND_ERR_CLOSED':
+            return HttpErrorReason.Cancelled;
+        case 'UND_ERR_SOCKET':
+            return HttpErrorReason.Network;
+        case 'UND_ERR_INFO':
+        case 'UND_ERR_NOT_SUPPORTED':
+        case 'UND_ERR_BPL_MISSING_UPSTREAM':
+        case 'UND_ERR_RES_EXCEEDED_MAX_SIZE':
+        default:
+            return HttpErrorReason.Unknown;
+    }
+}

package/http/client/http-client-response.d.ts

@@ -11,7 +11,7 @@ export type HttpClientResponseObject = TypedOmit<HttpClientResponse, 'hasBody' |
 export type HttpClientResponseOptions = {
     request: HttpClientRequest;
     statusCode: number;
-    statusMessage: string;
+    statusMessage: string | null;
     headers: HttpHeadersObject | HttpHeaders;
     body: HttpBody | HttpBodySource;
     closeHandler: () => void;
@@ -20,7 +20,7 @@ export declare class HttpClientResponse {
     private readonly closeHandler;
     readonly request: HttpClientRequest;
     readonly statusCode: number;
-    readonly statusMessage: string;
+    readonly statusMessage: string | null;
     readonly headers: HttpHeaders;
     readonly body: HttpBody;
     get hasBody(): boolean;

package/http/client/http-client-response.js

@@ -1,3 +1,4 @@
+import { isString } from '../../utils/type-guards.js';
 import { HttpBody } from '../http-body.js';
 import { HttpHeaders } from '../http-headers.js';
 export class HttpClientResponse {
@@ -13,7 +14,7 @@ export class HttpClientResponse {
     constructor(options) {
         this.request = options.request;
         this.statusCode = options.statusCode;
-        this.statusMessage = options.statusMessage;
+        this.statusMessage = (isString(options.statusMessage) && (options.statusMessage.length > 0)) ? options.statusMessage : null;
         this.headers = new HttpHeaders(options.headers);
         this.body = (options.body instanceof HttpBody) ? options.body : new HttpBody(options.body, this.headers);
         this.closeHandler = options.closeHandler;

package/http/client/http-client.js

@@ -240,7 +240,7 @@ async function errorMiddleware(request, next) {
     try {
         const response = await next(request);
         if (request.throwOnNon200 && ((response.statusCode < 200) || (response.statusCode >= 400))) {
-            const httpError = await HttpError.create(HttpErrorReason.Non200StatusCode, request, response, `Status code ${response.statusCode}.`);
+            const httpError = await HttpError.create(HttpErrorReason.StatusCode, request, response, `Status code ${response.statusCode}.`);
             throw httpError;
         }
         return response;

package/http/http.error.d.ts

@@ -5,9 +5,12 @@ import type { HttpClientRequest, HttpClientRequestObject, HttpClientResponse, Ht
 export declare enum HttpErrorReason {
     Unknown = "Unknown",
     Cancelled = "Cancelled",
+    Network = "Network",
     InvalidRequest = "InvalidRequest",
-    Non200StatusCode = "Non200StatusCode",
+    StatusCode = "StatusCode",
+    /** Valid http response containing an error */
     ErrorResponse = "ErrorResponse",
+    /** Invalid http response */
     ResponseError = "ResponseError",
     Timeout = "Timeout"
 }

package/http/http.error.js

@@ -5,9 +5,12 @@ export var HttpErrorReason;
 (function (HttpErrorReason) {
     HttpErrorReason["Unknown"] = "Unknown";
     HttpErrorReason["Cancelled"] = "Cancelled";
+    HttpErrorReason["Network"] = "Network";
     HttpErrorReason["InvalidRequest"] = "InvalidRequest";
-    HttpErrorReason["Non200StatusCode"] = "Non200StatusCode";
+    HttpErrorReason["StatusCode"] = "StatusCode";
+    /** Valid http response containing an error */
     HttpErrorReason["ErrorResponse"] = "ErrorResponse";
+    /** Invalid http response */
     HttpErrorReason["ResponseError"] = "ResponseError";
     HttpErrorReason["Timeout"] = "Timeout";
 })(HttpErrorReason || (HttpErrorReason = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.5",
+  "version": "0.90.6",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"