@ethlete/query 5.28.1 → 5.29.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ethlete/query
 
+## 5.29.1
+
+### Patch Changes
+
+- [`e30dff4`](https://github.com/ethlete-io/ethdk/commit/e30dff42ce2d5c5f2a976888b8aad112814c710e) Thanks [@TomTomB](https://github.com/TomTomB)! - Add missing export for query error response
+
+## 5.29.0
+
+### Minor Changes
+
+- [`089ce09`](https://github.com/ethlete-io/ethdk/commit/089ce09cb72b4420a49d6f165776fe3f391dc2fe) Thanks [@TomTomB](https://github.com/TomTomB)! - Add query error response parsing to query 3
+
+- [`089ce09`](https://github.com/ethlete-io/ethdk/commit/089ce09cb72b4420a49d6f165776fe3f391dc2fe) Thanks [@TomTomB](https://github.com/TomTomB)! - Add pipes for parsing http status codes
+
 ## 5.28.1
 
 ### Patch Changes

package/fesm2022/ethlete-query.mjs

@@ -1,13 +1,13 @@
 import * as i1 from '@ethlete/core';
 import { createDestroy, computedTillTruthy, syncSignal, getCookie, setCookie, deleteCookie, DelayableDirective, nextFrame, RuntimeError, isObject, injectRoute, getDomain, previousSignalValue, injectQueryParamChanges, injectQueryParams, clone, equal, ET_PROPERTY_REMOVED } from '@ethlete/core';
 import { Observable, takeUntil, startWith, pairwise, tap, switchMap, of, BehaviorSubject, Subject, fromEvent, timer, take, filter, takeWhile, map, shareReplay, ReplaySubject, combineLatest, interval, skip, withLatestFrom, debounceTime, Subscription, retry, throwError, catchError, merge } from 'rxjs';
+import { HttpStatusCode, HttpErrorResponse, HttpEventType, HttpClient, HttpHeaders } from '@angular/common/http';
 import * as i0 from '@angular/core';
 import { assertInInjectionContext, inject, Injector, computed, signal, isDevMode, untracked, TemplateRef, ViewContainerRef, ErrorHandler, ChangeDetectorRef, Directive, Input, InjectionToken, ElementRef, Pipe, effect, Component, ChangeDetectionStrategy, ViewEncapsulation, runInInjectionContext, EnvironmentInjector, createEnvironmentInjector, DestroyRef, NgZone } from '@angular/core';
 import { toSignal, toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { AsyncPipe, JsonPipe, NgClass } from '@angular/common';
 import * as i1$1 from '@angular/forms';
 import { FormControl, ReactiveFormsModule, FormGroup } from '@angular/forms';
-import { HttpErrorResponse, HttpStatusCode, HttpEventType, HttpClient, HttpHeaders } from '@angular/common/http';
 import { getActiveConsumer, setActiveConsumer } from '@angular/core/primitives/signals';
 import { io } from 'socket.io-client';
 import { Router, ActivatedRoute } from '@angular/router';
@@ -313,11 +313,11 @@ const shouldRetryRequest$1 = (config) => {
         return { retry: true, delay: defaultRetryDelay };
     }
     // Retry on 408 or 425 errors
-    if (status === 408 /* HttpStatusCode.RequestTimeout */ || status === 425 /* HttpStatusCode.TooEarly */) {
+    if (status === HttpStatusCode.RequestTimeout || status === HttpStatusCode.TooEarly) {
         return { retry: true, delay: defaultRetryDelay };
     }
     // Retry on 429 errors
-    if (status === 429 /* HttpStatusCode.TooManyRequests */) {
+    if (status === HttpStatusCode.TooManyRequests) {
         const retryAfter = config.headers['retry-after'] ||
             config.headers['Retry-After'] ||
             config.headers['x-retry-after'] ||
@@ -394,11 +394,11 @@ const request = (config) => {
             const { headers, statusText, url } = partialFromXhr();
             let { status } = partialFromXhr();
             let body = null;
-            if (status !== 204 /* HttpStatusCode.NoContent */) {
+            if (status !== HttpStatusCode.NoContent) {
                 body = typeof xhr.response === 'undefined' ? xhr.responseText : xhr.response;
             }
             if (status === 0) {
-                status = body ? 200 /* HttpStatusCode.Ok */ : 0;
+                status = body ? HttpStatusCode.Ok : 0;
             }
             let ok = status >= 200 && status < 300;
             if (responseType === 'json' && typeof body === 'string') {
@@ -1069,11 +1069,11 @@ const resetPageOnError = (config) => (source) => {
             }
             switch (state.error.status) {
                 // The page is invalid (in prod mode, code is 416)
-                case 416 /* HttpStatusCode.RangeNotSatisfiable */:
+                case HttpStatusCode.RangeNotSatisfiable:
                     queryForm.form.controls[pageControlKey]?.patchValue(1);
                     break;
                 // The page might be invalid (in dev mode, code is 500)
-                case 500 /* HttpStatusCode.InternalServerError */:
+                case HttpStatusCode.InternalServerError:
                     if (isSymfonyPagerfantaOutOfRangeError(state.error.detail)) {
                         queryForm.form.controls[pageControlKey].patchValue(1);
                     }
@@ -1548,7 +1548,7 @@ class Query {
                 const bearerAuthProvider = this._getBearerAuthProvider();
                 if (!bearerAuthProvider ||
                     options?._isUnauthorizedRetry ||
-                    error.status !== 401 /* HttpStatusCode.Unauthorized */ ||
+                    error.status !== HttpStatusCode.Unauthorized ||
                     !bearerAuthProvider.shouldRefreshOnUnauthorizedResponse) {
                     return failure();
                 }
@@ -3012,7 +3012,7 @@ const createBearerAuthProvider = (options) => {
         const isCookieEnabled = cookieEnabled();
         const res = latestExecutedQuery();
         const error = res?.query?.query.error();
-        if (!isCookieEnabled || (error && error.status === 401)) {
+        if (!isCookieEnabled || (error && error.raw.status === 401)) {
             deleteCookie$1();
             return;
         }
@@ -3445,6 +3445,69 @@ const buildQueryCacheKey = (route, args) => {
     return hash.toString();
 };
 
+const createQueryErrorResponse = (error) => {
+    let err = error instanceof HttpErrorResponse ? error : null;
+    if (!err) {
+        err = new HttpErrorResponse({
+            error: error,
+            status: 0,
+            statusText: 'Unknown Error',
+        });
+    }
+    const retryState = shouldRetryRequest(err);
+    const detail = err.error;
+    const errorList = [];
+    if (isClassValidatorError(detail)) {
+        for (const error of detail.message) {
+            errorList.push({ message: error });
+        }
+    }
+    else if (isSymfonyFormViolationListError(detail)) {
+        for (const violation of detail.violations) {
+            errorList.push({ message: violation.message });
+        }
+    }
+    else if (isSymfonyListError(detail)) {
+        for (const error of detail) {
+            errorList.push({ message: error.message });
+        }
+    }
+    else if (typeof detail === 'object' && !!detail && 'message' in detail && typeof detail.message === 'string') {
+        errorList.push({ message: detail.message });
+    }
+    else if (typeof detail === 'object' && !!detail && 'detail' in detail && typeof detail.detail === 'string') {
+        // Symfony error response (during development)
+        errorList.push({ message: detail.detail });
+    }
+    else if (typeof detail === 'string') {
+        errorList.push({ message: detail });
+    }
+    else if (Array.isArray(detail) && detail.length > 0 && typeof detail[0] === 'string') {
+        for (const error of detail) {
+            errorList.push({ message: error });
+        }
+    }
+    if (errorList.length > 0) {
+        return {
+            isList: true,
+            errors: errorList,
+            raw: err,
+            retryState,
+            code: err.status,
+        };
+    }
+    else {
+        const singleError = errorList[0] ?? { message: err.message };
+        return {
+            isList: false,
+            error: singleError,
+            raw: err,
+            retryState,
+            code: err.status,
+        };
+    }
+};
+
 const SPEED_BUFFER_TIME_IN_MS = 2000;
 const createHttpRequest = (options) => {
     let currentStreamSubscription = Subscription.EMPTY;
@@ -3539,17 +3602,10 @@ const createHttpRequest = (options) => {
         }
     };
     const updateErrorState = (errorResponse) => {
-        let err = errorResponse instanceof HttpErrorResponse ? errorResponse : null;
-        if (!err) {
-            err = new HttpErrorResponse({
-                error: errorResponse,
-                status: 0,
-                statusText: 'Unknown Error',
-            });
-        }
-        error.set(err);
+        const errorRes = createQueryErrorResponse(errorResponse);
+        error.set(errorRes);
         loading.set(null);
-        currentEvent.set({ type: 'error', error: err });
+        currentEvent.set({ type: 'error', error: errorRes });
     };
     const updateLoadingState = (event) => {
         if (event.total === undefined) {
@@ -3759,6 +3815,7 @@ const withResponseUpdate = (options) => {
     });
 };
 
+/* eslint-disable @typescript-eslint/no-explicit-any */
 /** Transforms an array of arrays into a single array and filters out `null` values. */
 const transformArrayResponse = (responses) => responses.filter((r) => !!r).flatMap((r) => r);
 /** Transforms an array of paginated responses into a single array and filters out `null` values. */
@@ -3841,6 +3898,7 @@ const createQueryStack = (options) => {
     return stack;
 };
 
+/* eslint-disable @typescript-eslint/no-explicit-any */
 const ethletePaginationAdapter = (response) => {
     const pagination = {
         items: response.items,
@@ -4005,7 +4063,7 @@ const createPagedQueryStack = (options) => {
             for (const [index, query] of stack.queries().entries()) {
                 const res = query.response();
                 const err = query.error();
-                const isErroredAndCanBeRetried = err && shouldRetryRequest(err);
+                const isErroredAndCanBeRetried = err && shouldRetryRequest(err.raw);
                 if (isErroredAndCanBeRetried) {
                     queriesToExecute.add(query);
                 }
@@ -4580,6 +4638,410 @@ const createGqlMutationViaPost = (client) => {
     return (query, creatorOptions) => createGqlQueryCreator(creatorOptions, { method: 'MUTATE', client, transport: 'POST', query });
 };
 
+const parseHttpErrorCodeToTitleDe = (statusCode) => {
+    switch (statusCode) {
+        case HttpStatusCode.BadRequest:
+            return 'Ungültige Anfrage';
+        case HttpStatusCode.Unauthorized:
+            return 'Nicht autorisiert';
+        case HttpStatusCode.PaymentRequired:
+            return 'Zahlung erforderlich';
+        case HttpStatusCode.Forbidden:
+            return 'Verboten';
+        case HttpStatusCode.NotFound:
+            return 'Nicht gefunden';
+        case HttpStatusCode.MethodNotAllowed:
+            return 'Methode nicht erlaubt';
+        case HttpStatusCode.NotAcceptable:
+            return 'Nicht akzeptabel';
+        case HttpStatusCode.ProxyAuthenticationRequired:
+            return 'Proxy-Authentifizierung erforderlich';
+        case HttpStatusCode.RequestTimeout:
+            return 'Anforderungszeitüberschreitung';
+        case HttpStatusCode.Conflict:
+            return 'Konflikt';
+        case HttpStatusCode.Gone:
+            return 'Weg';
+        case HttpStatusCode.LengthRequired:
+            return 'Länge erforderlich';
+        case HttpStatusCode.PreconditionFailed:
+            return 'Vorbedingung fehlgeschlagen';
+        case HttpStatusCode.PayloadTooLarge:
+            return 'Nutzlast zu groß';
+        case HttpStatusCode.UriTooLong:
+            return 'URI zu lang';
+        case HttpStatusCode.UnsupportedMediaType:
+            return 'Nicht unterstützter Medientyp';
+        case HttpStatusCode.RangeNotSatisfiable:
+            return 'Bereich nicht zufriedenstellend';
+        case HttpStatusCode.ExpectationFailed:
+            return 'Erwartung fehlgeschlagen';
+        case HttpStatusCode.ImATeapot:
+            return 'Ich bin eine Teekanne';
+        case HttpStatusCode.MisdirectedRequest:
+            return 'Fehlgeleitete Anfrage';
+        case HttpStatusCode.UnprocessableEntity:
+            return 'Unverarbeitbare Entität';
+        case HttpStatusCode.Locked:
+            return 'Gesperrt';
+        case HttpStatusCode.FailedDependency:
+            return 'Fehlgeschlagene Abhängigkeit';
+        case HttpStatusCode.TooEarly:
+            return 'Zu früh';
+        case HttpStatusCode.UpgradeRequired:
+            return 'Upgrade erforderlich';
+        case HttpStatusCode.PreconditionRequired:
+            return 'Vorbedingung erforderlich';
+        case HttpStatusCode.TooManyRequests:
+            return 'Zu viele Anfragen';
+        case HttpStatusCode.RequestHeaderFieldsTooLarge:
+            return 'Anforderungskopffelder zu groß';
+        case HttpStatusCode.UnavailableForLegalReasons:
+            return 'Aus rechtlichen Gründen nicht verfügbar';
+        case HttpStatusCode.InternalServerError:
+            return 'Interner Serverfehler';
+        case HttpStatusCode.NotImplemented:
+            return 'Nicht implementiert';
+        case HttpStatusCode.BadGateway:
+            return 'Schlechtes Gateway';
+        case HttpStatusCode.ServiceUnavailable:
+            return 'Dienst nicht verfügbar';
+        case HttpStatusCode.GatewayTimeout:
+            return 'Gateway-Zeitüberschreitung';
+        case HttpStatusCode.HttpVersionNotSupported:
+            return 'HTTP-Version nicht unterstützt';
+        case HttpStatusCode.VariantAlsoNegotiates:
+            return 'Variante verhandelt auch';
+        case HttpStatusCode.InsufficientStorage:
+            return 'Unzureichender Speicher';
+        case HttpStatusCode.LoopDetected:
+            return 'Schleifenerkennung';
+        case HttpStatusCode.NotExtended:
+            return 'Nicht erweitert';
+        case HttpStatusCode.NetworkAuthenticationRequired:
+            return 'Netzwerkauthentifizierung erforderlich';
+        default:
+            return 'Etwas ist schief gelaufen';
+    }
+};
+const parseHttpErrorCodeToMessageDe = (statusCode) => {
+    switch (statusCode) {
+        case HttpStatusCode.BadRequest:
+            return 'Entschuldigung, wir konnten Ihre Anfrage nicht bearbeiten. Bitte versuchen Sie es später erneut.';
+        case HttpStatusCode.Unauthorized:
+            return 'Sie sind nicht berechtigt, diese Aktion auszuführen. Bitte melden Sie sich an, um fortzufahren.';
+        case HttpStatusCode.PaymentRequired:
+            return 'Zur Ausführung dieser Aktion ist eine Zahlung erforderlich.';
+        case HttpStatusCode.Forbidden:
+            return 'Sie haben keine Berechtigung, diese Aktion auszuführen.';
+        case HttpStatusCode.NotFound:
+            return 'Die angeforderte Ressource wurde nicht gefunden.';
+        case HttpStatusCode.MethodNotAllowed:
+            return 'Die angeforderte Methode ist für diese Ressource nicht zulässig.';
+        case HttpStatusCode.NotAcceptable:
+            return 'Die angeforderte Ressource ist nicht in der Lage, eine Antwort zu generieren, die der Liste der akzeptablen Werte entspricht.';
+        case HttpStatusCode.ProxyAuthenticationRequired:
+            return 'Zur Ausführung dieser Aktion ist eine Proxy-Authentifizierung erforderlich.';
+        case HttpStatusCode.RequestTimeout:
+            return 'Der Server hat auf die Anforderung gewartet.';
+        case HttpStatusCode.Conflict:
+            return 'Die Anforderung steht im Widerspruch zum aktuellen Zustand der Ressource.';
+        case HttpStatusCode.Gone:
+            return 'Die angeforderte Ressource ist nicht mehr verfügbar und wird auch nicht mehr verfügbar sein.';
+        case HttpStatusCode.LengthRequired:
+            return 'Die Anforderung hat die Länge ihres Inhalts nicht angegeben, die von der angeforderten Ressource benötigt wird.';
+        case HttpStatusCode.PreconditionFailed:
+            return 'Der Server erfüllt eine der Voraussetzungen nicht, die der Anforderer an die Anforderung gestellt hat.';
+        case HttpStatusCode.PayloadTooLarge:
+            return 'Die Anforderung ist größer als der Server bereit oder in der Lage ist, zu verarbeiten.';
+        case HttpStatusCode.UriTooLong:
+            return 'Die bereitgestellte URL war für den Server zu lang, um sie zu verarbeiten.';
+        case HttpStatusCode.UnsupportedMediaType:
+            return 'Die Anforderungseinheit hat einen Medientyp, den der Server oder die Ressource nicht unterstützt.';
+        case HttpStatusCode.RangeNotSatisfiable:
+            return 'Der Client hat einen Teil der Datei angefordert, aber der Server kann diesen Teil nicht liefern.';
+        case HttpStatusCode.ExpectationFailed:
+            return 'Der Server kann die Anforderungen des Erwartung-Anforderungskopffelds nicht erfüllen.';
+        case HttpStatusCode.ImATeapot:
+            return 'Ich bin eine Teekanne.';
+        case HttpStatusCode.MisdirectedRequest:
+            return 'Die Anforderung wurde an einen Server gerichtet, der nicht in der Lage ist, eine Antwort zu generieren.';
+        case HttpStatusCode.UnprocessableEntity:
+            return 'Die Anforderung war gut formuliert, konnte aber aufgrund semantischer Fehler nicht befolgt werden.';
+        case HttpStatusCode.Locked:
+            return 'Die Ressource, auf die zugegriffen wird, ist gesperrt.';
+        case HttpStatusCode.FailedDependency:
+            return 'Die Anforderung ist aufgrund eines Fehlers einer vorherigen Anforderung fehlgeschlagen.';
+        case HttpStatusCode.TooEarly:
+            return 'Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil der Benutzer nicht authentifiziert wurde.';
+        case HttpStatusCode.UpgradeRequired:
+            return 'Der Client sollte zu einem anderen Protokoll wie TLS/1.0 wechseln, das im Upgrade-Anforderungskopffeld angegeben ist.';
+        case HttpStatusCode.PreconditionRequired:
+            return 'Der Ursprungsserver erfordert, dass die Anforderung bedingt ist.';
+        case HttpStatusCode.TooManyRequests:
+            return 'Sie haben in einer bestimmten Zeit zu viele Anfragen gesendet. Bitte versuchen Sie es später erneut.';
+        case HttpStatusCode.RequestHeaderFieldsTooLarge:
+            return 'Der Server ist nicht bereit, die Anforderung zu verarbeiten, weil seine Kopffelder zu groß sind.';
+        case HttpStatusCode.UnavailableForLegalReasons:
+            return 'Die Ressource ist aufgrund einer rechtlichen Forderung nicht verfügbar.';
+        case HttpStatusCode.InternalServerError:
+            return 'Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut.';
+        case HttpStatusCode.NotImplemented:
+            return 'Der Server unterstützt die zur Erfüllung der Anforderung erforderliche Funktionalität nicht.';
+        case HttpStatusCode.BadGateway:
+            return 'Etwas ist schief gelaufen. Bitte versuchen Sie es später erneut.';
+        case HttpStatusCode.ServiceUnavailable:
+            return 'Der Server kann die Anforderung derzeit nicht bearbeiten, da er vorübergehend überlastet oder gewartet wird.';
+        case HttpStatusCode.GatewayTimeout:
+            return 'Der Server hat beim Versuch, die Anforderung abzuschließen, keine rechtzeitige Antwort vom Server erhalten.';
+        case HttpStatusCode.HttpVersionNotSupported:
+            return 'Der Server unterstützt die in der Anforderung verwendete HTTP-Protokollversion nicht.';
+        case HttpStatusCode.VariantAlsoNegotiates:
+            return 'Der Server hat einen internen Konfigurationsfehler: Die ausgewählte Variantenressource ist so konfiguriert, dass sie sich selbst in die transparente Inhaltsverhandlung einbindet, und ist daher kein geeigneter Endpunkt im Verhandlungsprozess.';
+        case HttpStatusCode.InsufficientStorage:
+            return 'Die Methode konnte auf die Ressource nicht angewendet werden, weil der Server nicht in der Lage ist, die für die erfolgreiche Ausführung der Anforderung erforderliche Darstellung zu speichern.';
+        case HttpStatusCode.LoopDetected:
+            return 'Der Server hat eine Endlosschleife erkannt, während er die Anforderung verarbeitet.';
+        case HttpStatusCode.NotExtended:
+            return 'Weitere Erweiterungen der Anforderung sind erforderlich, damit der Server sie erfüllen kann.';
+        case HttpStatusCode.NetworkAuthenticationRequired:
+            return 'Sie müssen sich authentifizieren, um Zugang zum Netzwerk zu erhalten.';
+        default:
+            return 'Etwas ist schief gelaufen. Überprüfen Sie Ihre Internetverbindung und versuchen Sie es später erneut.';
+    }
+};
+
+class ParseHttpErrorCodeToTitleDePipe {
+    constructor() {
+        this.transform = parseHttpErrorCodeToTitleDe;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToTitleDePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToTitleDePipe, isStandalone: true, name: "parseHttpErrorCodeToTitleDe" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToTitleDePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'parseHttpErrorCodeToTitleDe',
+                    standalone: true,
+                }]
+        }] });
+class ParseHttpErrorCodeToMessageDePipe {
+    constructor() {
+        this.transform = parseHttpErrorCodeToMessageDe;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToMessageDePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToMessageDePipe, isStandalone: true, name: "parseHttpErrorCodeToMessageDe" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToMessageDePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'parseHttpErrorCodeToMessageDe',
+                    standalone: true,
+                }]
+        }] });
+
+const parseHttpErrorCodeToTitleEn = (statusCode) => {
+    switch (statusCode) {
+        case HttpStatusCode.BadRequest:
+            return 'Bad request';
+        case HttpStatusCode.Unauthorized:
+            return 'Unauthorized';
+        case HttpStatusCode.PaymentRequired:
+            return 'Payment required';
+        case HttpStatusCode.Forbidden:
+            return 'Forbidden';
+        case HttpStatusCode.NotFound:
+            return 'Not found';
+        case HttpStatusCode.MethodNotAllowed:
+            return 'Method not allowed';
+        case HttpStatusCode.NotAcceptable:
+            return 'Not acceptable';
+        case HttpStatusCode.ProxyAuthenticationRequired:
+            return 'Proxy authentication required';
+        case HttpStatusCode.RequestTimeout:
+            return 'Request timeout';
+        case HttpStatusCode.Conflict:
+            return 'Conflict';
+        case HttpStatusCode.Gone:
+            return 'Gone';
+        case HttpStatusCode.LengthRequired:
+            return 'Length required';
+        case HttpStatusCode.PreconditionFailed:
+            return 'Precondition failed';
+        case HttpStatusCode.PayloadTooLarge:
+            return 'Payload too large';
+        case HttpStatusCode.UriTooLong:
+            return 'URI too long';
+        case HttpStatusCode.UnsupportedMediaType:
+            return 'Unsupported media type';
+        case HttpStatusCode.RangeNotSatisfiable:
+            return 'Range not satisfiable';
+        case HttpStatusCode.ExpectationFailed:
+            return 'Expectation failed';
+        case HttpStatusCode.ImATeapot:
+            return 'I am a teapot';
+        case HttpStatusCode.MisdirectedRequest:
+            return 'Misdirected request';
+        case HttpStatusCode.UnprocessableEntity:
+            return 'Unprocessable entity';
+        case HttpStatusCode.Locked:
+            return 'Locked';
+        case HttpStatusCode.FailedDependency:
+            return 'Failed dependency';
+        case HttpStatusCode.TooEarly:
+            return 'Too early';
+        case HttpStatusCode.UpgradeRequired:
+            return 'Upgrade required';
+        case HttpStatusCode.PreconditionRequired:
+            return 'Precondition required';
+        case HttpStatusCode.TooManyRequests:
+            return 'Too many requests';
+        case HttpStatusCode.RequestHeaderFieldsTooLarge:
+            return 'Request header fields too large';
+        case HttpStatusCode.UnavailableForLegalReasons:
+            return 'Unavailable for legal reasons';
+        case HttpStatusCode.InternalServerError:
+            return 'Internal server error';
+        case HttpStatusCode.NotImplemented:
+            return 'Not implemented';
+        case HttpStatusCode.BadGateway:
+            return 'Bad gateway';
+        case HttpStatusCode.ServiceUnavailable:
+            return 'Service unavailable';
+        case HttpStatusCode.GatewayTimeout:
+            return 'Gateway timeout';
+        case HttpStatusCode.HttpVersionNotSupported:
+            return 'HTTP version not supported';
+        case HttpStatusCode.VariantAlsoNegotiates:
+            return 'Variant also negotiates';
+        case HttpStatusCode.InsufficientStorage:
+            return 'Insufficient storage';
+        case HttpStatusCode.LoopDetected:
+            return 'Loop detected';
+        case HttpStatusCode.NotExtended:
+            return 'Not extended';
+        case HttpStatusCode.NetworkAuthenticationRequired:
+            return 'Network authentication required';
+        default:
+            return 'Something went wrong';
+    }
+};
+const parseHttpErrorCodeToMessageEn = (statusCode) => {
+    switch (statusCode) {
+        case HttpStatusCode.BadRequest:
+            return 'Sorry, we could not process your request. Please try again later.';
+        case HttpStatusCode.Unauthorized:
+            return 'You are not authorized to perform this action. Please log in to continue.';
+        case HttpStatusCode.PaymentRequired:
+            return 'Payment is required to complete this action.';
+        case HttpStatusCode.Forbidden:
+            return 'You do not have permission to perform this action.';
+        case HttpStatusCode.NotFound:
+            return 'The requested resource was not found.';
+        case HttpStatusCode.MethodNotAllowed:
+            return 'The requested method is not allowed for this resource.';
+        case HttpStatusCode.NotAcceptable:
+            return 'The requested resource is not capable of generating a response matching the list of acceptable values.';
+        case HttpStatusCode.ProxyAuthenticationRequired:
+            return 'Proxy authentication is required to complete this action.';
+        case HttpStatusCode.RequestTimeout:
+            return 'The server timed out waiting for the request.';
+        case HttpStatusCode.Conflict:
+            return 'The request conflicts with the current state of the resource.';
+        case HttpStatusCode.Gone:
+            return 'The requested resource is no longer available and will not be available again.';
+        case HttpStatusCode.LengthRequired:
+            return 'The request did not specify the length of its content, which is required by the requested resource.';
+        case HttpStatusCode.PreconditionFailed:
+            return 'The server does not meet one of the preconditions that the requester put on the request.';
+        case HttpStatusCode.PayloadTooLarge:
+            return 'The request is larger than the server is willing or able to process.';
+        case HttpStatusCode.UriTooLong:
+            return 'The URL provided was too long for the server to process.';
+        case HttpStatusCode.UnsupportedMediaType:
+            return 'The request entity has a media type which the server or resource does not support.';
+        case HttpStatusCode.RangeNotSatisfiable:
+            return 'The client has asked for a portion of the file, but the server cannot supply that portion.';
+        case HttpStatusCode.ExpectationFailed:
+            return 'The server cannot meet the requirements of the Expect request-header field.';
+        case HttpStatusCode.ImATeapot:
+            return 'I am a teapot.';
+        case HttpStatusCode.MisdirectedRequest:
+            return 'The request was directed at a server that is not able to produce a response.';
+        case HttpStatusCode.UnprocessableEntity:
+            return 'The request was well-formed but was unable to be followed due to semantic errors.';
+        case HttpStatusCode.Locked:
+            return 'The resource that is being accessed is locked.';
+        case HttpStatusCode.FailedDependency:
+            return 'The request failed due to failure of a previous request.';
+        case HttpStatusCode.TooEarly:
+            return 'The server is unwilling to process the request because the user has not been authenticated.';
+        case HttpStatusCode.UpgradeRequired:
+            return 'The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header field.';
+        case HttpStatusCode.PreconditionRequired:
+            return 'The origin server requires the request to be conditional.';
+        case HttpStatusCode.TooManyRequests:
+            return 'You have sent too many requests in a given amount of time. Please try again later.';
+        case HttpStatusCode.RequestHeaderFieldsTooLarge:
+            return 'The server is unwilling to process the request because its header fields are too large.';
+        case HttpStatusCode.UnavailableForLegalReasons:
+            return 'The resource is unavailable due to a legal demand.';
+        case HttpStatusCode.InternalServerError:
+            return 'Something went wrong on our end. Please try again later.';
+        case HttpStatusCode.NotImplemented:
+            return 'The server does not support the functionality required to fulfill the request.';
+        case HttpStatusCode.BadGateway:
+            return 'Something went wrong on our end. Please try again later.';
+        case HttpStatusCode.ServiceUnavailable:
+            return 'The server is currently unable to handle the request due to a temporary overload or maintenance of the server.';
+        case HttpStatusCode.GatewayTimeout:
+            return 'The server, while acting as a gateway or proxy, did not receive a timely response from the upstream server specified by the URL or some other auxiliary server it needed to access in attempting to complete the request.';
+        case HttpStatusCode.HttpVersionNotSupported:
+            return 'The server does not support the HTTP protocol version used in the request.';
+        case HttpStatusCode.VariantAlsoNegotiates:
+            return 'The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process.';
+        case HttpStatusCode.InsufficientStorage:
+            return 'The method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request.';
+        case HttpStatusCode.LoopDetected:
+            return 'The server detected an infinite loop while processing the request.';
+        case HttpStatusCode.NotExtended:
+            return 'Further extensions to the request are required for the server to fulfill it.';
+        case HttpStatusCode.NetworkAuthenticationRequired:
+            return 'You need to authenticate to gain network access.';
+        default:
+            return 'Something went wrong. Check your internet connection and try again later.';
+    }
+};
+
+class ParseHttpErrorCodeToTitleEnPipe {
+    constructor() {
+        this.transform = parseHttpErrorCodeToTitleEn;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToTitleEnPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToTitleEnPipe, isStandalone: true, name: "parseHttpErrorCodeToTitleEn" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToTitleEnPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'parseHttpErrorCodeToTitleEn',
+                    standalone: true,
+                }]
+        }] });
+class ParseHttpErrorCodeToMessageEnPipe {
+    constructor() {
+        this.transform = parseHttpErrorCodeToMessageEn;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToMessageEnPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToMessageEnPipe, isStandalone: true, name: "parseHttpErrorCodeToMessageEn" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ParseHttpErrorCodeToMessageEnPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'parseHttpErrorCodeToMessageEn',
+                    standalone: true,
+                }]
+        }] });
+
 const roomNotJoined = (room) => {
     return new RuntimeError(1000 /* WebSocketRuntimeErrorCode.ROOM_NOT_JOINED */, `Tried leaving the room "${room}" but it has not been joined.`);
 };
@@ -4702,6 +5164,10 @@ const createWebSocketClientConfig = (options) => {
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     CLEAR_QUERY_ARGS: CLEAR_QUERY_ARGS,
+    ParseHttpErrorCodeToMessageDePipe: ParseHttpErrorCodeToMessageDePipe,
+    ParseHttpErrorCodeToMessageEnPipe: ParseHttpErrorCodeToMessageEnPipe,
+    ParseHttpErrorCodeToTitleDePipe: ParseHttpErrorCodeToTitleDePipe,
+    ParseHttpErrorCodeToTitleEnPipe: ParseHttpErrorCodeToTitleEnPipe,
     QUERY_EFFECT_ERROR_MESSAGE: QUERY_EFFECT_ERROR_MESSAGE,
     SPEED_BUFFER_TIME_IN_MS: SPEED_BUFFER_TIME_IN_MS,
     applyQueryFeatures: applyQueryFeatures,
@@ -4731,6 +5197,7 @@ var index = /*#__PURE__*/Object.freeze({
     createQueryClient: createQueryClient,
     createQueryClientConfig: createQueryClientConfig,
     createQueryCreator: createQueryCreator,
+    createQueryErrorResponse: createQueryErrorResponse,
     createQueryObject: createQueryObject,
     createQueryRepository: createQueryRepository,
     createQuerySnapshotFn: createQuerySnapshotFn,
@@ -4764,6 +5231,10 @@ var index = /*#__PURE__*/Object.freeze({
     pagedQueryStackNextPageCalledWithoutPreviousPage: pagedQueryStackNextPageCalledWithoutPreviousPage,
     pagedQueryStackPageBiggerThanTotalPages: pagedQueryStackPageBiggerThanTotalPages,
     pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage: pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage,
+    parseHttpErrorCodeToMessageDe: parseHttpErrorCodeToMessageDe,
+    parseHttpErrorCodeToMessageEn: parseHttpErrorCodeToMessageEn,
+    parseHttpErrorCodeToTitleDe: parseHttpErrorCodeToTitleDe,
+    parseHttpErrorCodeToTitleEn: parseHttpErrorCodeToTitleEn,
     provideBearerAuthProvider: provideBearerAuthProvider,
     provideQueryClient: provideQueryClient,
     provideWebSocketClient: provideWebSocketClient,
@@ -5309,5 +5780,5 @@ class QueryForm {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicAuthProvider, BearerAuthProvider, CustomHeaderAuthProvider, EntityStore, index as ExperimentalQuery, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, QUERY_CLIENT_DEVTOOLS_TOKEN, Query, QueryClient, QueryCreator, QueryDevtoolsComponent, QueryDirective, QueryError, QueryField, QueryForm, QueryShortNamePipe, QueryStore, addQueryContainerHandling, buildErrorMessage, buildQueryCacheKey$1 as buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, createInfinityQueryConfig, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, decryptBearer, deepFreeze, def, detectContentTypeHeader, extractExpiresInSeconds$1 as extractExpiresInSeconds, extractQuery, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getResponseUrl, gql, hasHeader, ignoreAutoRefresh, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isNaN$1 as isNaN, isQuery, isQueryCollection, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mergeHeaders, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, pathParamsMissingInRouteFunctionError, provideQueryClientForDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetPageOnError, serializeBody, shouldCacheQuery$1 as shouldCacheQuery, shouldRetryRequest$1 as shouldRetryRequest, skipPaginationPageParamCalculator, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, transformGql, transformMethod, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray };
+export { BasicAuthProvider, BearerAuthProvider, CustomHeaderAuthProvider, EntityStore, index as ExperimentalQuery, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, Query, QueryClient, QueryCreator, QueryDevtoolsComponent, QueryDirective, QueryError, QueryField, QueryForm, QueryShortNamePipe, QueryStore, addQueryContainerHandling, buildErrorMessage, buildQueryCacheKey$1 as buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, createInfinityQueryConfig, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, decryptBearer, deepFreeze, def, detectContentTypeHeader, extractExpiresInSeconds$1 as extractExpiresInSeconds, extractQuery, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getResponseUrl, gql, hasHeader, ignoreAutoRefresh, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isNaN$1 as isNaN, isQuery, isQueryCollection, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mergeHeaders, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideQueryClientForDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetPageOnError, serializeBody, shouldCacheQuery$1 as shouldCacheQuery, shouldRetryRequest$1 as shouldRetryRequest, skipPaginationPageParamCalculator, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, transformGql, transformMethod, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray };
 //# sourceMappingURL=ethlete-query.mjs.map