@nauth-toolkit/client-angular 0.1.57 → 0.1.58

package/esm2022/ngmodule/http-adapter.mjs

@@ -29,6 +29,37 @@ export class AngularHttpAdapter {
     constructor(http) {
         this.http = http;
     }
+    /**
+     * Safely parse a JSON response body.
+     *
+     * Angular's fetch backend (`withFetch()`) will throw a raw `SyntaxError` if
+     * `responseType: 'json'` is used and the backend returns HTML (common for
+     * proxies, 502 pages, SSR fallbacks, or misrouted requests).
+     *
+     * To avoid crashing consumer apps, we always request as text and then parse
+     * JSON only when the response actually looks like JSON.
+     *
+     * @param bodyText - Raw response body as text
+     * @param contentType - Content-Type header value (if available)
+     * @returns Parsed JSON value (unknown)
+     * @throws {SyntaxError} When body is non-empty but not valid JSON
+     */
+    parseJsonBody(bodyText, contentType) {
+        const trimmed = bodyText.trim();
+        if (!trimmed)
+            return null;
+        // If it's clearly HTML, never attempt JSON.parse (some proxies mislabel Content-Type).
+        if (trimmed.startsWith('<')) {
+            return bodyText;
+        }
+        const looksLikeJson = trimmed.startsWith('{') || trimmed.startsWith('[');
+        const isJsonContentType = typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');
+        if (!looksLikeJson && !isJsonContentType) {
+            // Return raw text when it doesn't look like JSON (e.g., HTML error pages).
+            return bodyText;
+        }
+        return JSON.parse(trimmed);
+    }
     /**
      * Execute HTTP request using Angular's HttpClient.
      *
@@ -38,29 +69,40 @@ export class AngularHttpAdapter {
      */
     async request(config) {
         try {
-            // Use Angular's HttpClient - goes through ALL interceptors
-            const data = await firstValueFrom(this.http.request(config.method, config.url, {
+            // Use Angular's HttpClient - goes through ALL interceptors.
+            // IMPORTANT: Use responseType 'text' to avoid raw JSON.parse crashes when
+            // the backend returns HTML (seen in some proxy/SSR/misroute setups).
+            const res = await firstValueFrom(this.http.request(config.method, config.url, {
                 body: config.body,
                 headers: config.headers,
                 withCredentials: config.credentials === 'include',
-                observe: 'body', // Only return body data
+                observe: 'response',
+                responseType: 'text',
             }));
+            const contentType = res.headers?.get('content-type');
+            const parsed = this.parseJsonBody(res.body ?? '', contentType);
             return {
-                data,
-                status: 200, // HttpClient only returns data on success
-                headers: {}, // Can extract from observe: 'response' if needed
+                data: parsed,
+                status: res.status,
+                headers: {}, // Reserved for future header passthrough if needed
             };
         }
         catch (error) {
             if (error instanceof HttpErrorResponse) {
-                // Convert Angular's HttpErrorResponse to NAuthClientError
-                const errorData = error.error || {};
-                const code = typeof errorData['code'] === 'string' ? errorData.code : NAuthErrorCode.INTERNAL_ERROR;
+                // Convert Angular's HttpErrorResponse to NAuthClientError.
+                // When using responseType 'text', `error.error` is typically a string.
+                const contentType = error.headers?.get('content-type') ?? null;
+                const rawBody = typeof error.error === 'string' ? error.error : '';
+                const parsedError = this.parseJsonBody(rawBody, contentType);
+                const errorData = typeof parsedError === 'object' && parsedError !== null ? parsedError : {};
+                const code = typeof errorData['code'] === 'string' ? errorData['code'] : NAuthErrorCode.INTERNAL_ERROR;
                 const message = typeof errorData['message'] === 'string'
-                    ? errorData.message
-                    : error.message || `Request failed with status ${error.status}`;
-                const timestamp = typeof errorData['timestamp'] === 'string' ? errorData.timestamp : undefined;
-                const details = errorData['details'];
+                    ? errorData['message']
+                    : typeof parsedError === 'string' && parsedError.trim()
+                        ? parsedError
+                        : error.message || `Request failed with status ${error.status}`;
+                const timestamp = typeof errorData['timestamp'] === 'string' ? errorData['timestamp'] : undefined;
+                const details = typeof errorData['details'] === 'object' ? errorData['details'] : undefined;
                 throw new NAuthClientError(code, message, {
                     statusCode: error.status,
                     timestamp,
@@ -68,8 +110,12 @@ export class AngularHttpAdapter {
                     isNetworkError: error.status === 0, // Network error (no response from server)
                 });
             }
-            // Re-throw non-HTTP errors
-            throw error;
+            // Re-throw non-HTTP errors as an SDK error so consumers don't see raw parser crashes.
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new NAuthClientError(NAuthErrorCode.INTERNAL_ERROR, message, {
+                statusCode: 0,
+                isNetworkError: true,
+            });
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularHttpAdapter, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -78,4 +124,4 @@ export class AngularHttpAdapter {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularHttpAdapter, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-adapter.js","sourceRoot":"","sources":["../../../src/ngmodule/http-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\nimport { HttpAdapter, HttpRequest, HttpResponse, NAuthClientError, NAuthErrorCode } from '@nauth-toolkit/client';\n\n/**\n * HTTP adapter for Angular using HttpClient.\n *\n * This adapter:\n * - Uses Angular's HttpClient for all requests\n * - Works with Angular's HTTP interceptors (including authInterceptor)\n * - Auto-provided via Angular DI (providedIn: 'root')\n * - Converts HttpClient responses to HttpResponse format\n * - Converts HttpErrorResponse to NAuthClientError\n *\n * Users don't need to configure this manually - it's automatically\n * injected when using AuthService in Angular apps.\n *\n * @example\n * ```typescript\n * // Automatic usage (no manual setup needed)\n * // AuthService automatically injects AngularHttpAdapter\n * constructor(private auth: AuthService) {}\n * ```\n */\n@Injectable()\nexport class AngularHttpAdapter implements HttpAdapter {\n  constructor(private readonly http: HttpClient) {}\n\n  /**\n   * Safely parse a JSON response body.\n   *\n   * Angular's fetch backend (`withFetch()`) will throw a raw `SyntaxError` if\n   * `responseType: 'json'` is used and the backend returns HTML (common for\n   * proxies, 502 pages, SSR fallbacks, or misrouted requests).\n   *\n   * To avoid crashing consumer apps, we always request as text and then parse\n   * JSON only when the response actually looks like JSON.\n   *\n   * @param bodyText - Raw response body as text\n   * @param contentType - Content-Type header value (if available)\n   * @returns Parsed JSON value (unknown)\n   * @throws {SyntaxError} When body is non-empty but not valid JSON\n   */\n  private parseJsonBody(bodyText: string, contentType: string | null): unknown {\n    const trimmed = bodyText.trim();\n    if (!trimmed) return null;\n\n    // If it's clearly HTML, never attempt JSON.parse (some proxies mislabel Content-Type).\n    if (trimmed.startsWith('<')) {\n      return bodyText;\n    }\n\n    const looksLikeJson = trimmed.startsWith('{') || trimmed.startsWith('[');\n    const isJsonContentType = typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');\n\n    if (!looksLikeJson && !isJsonContentType) {\n      // Return raw text when it doesn't look like JSON (e.g., HTML error pages).\n      return bodyText;\n    }\n\n    return JSON.parse(trimmed) as unknown;\n  }\n\n  /**\n   * Execute HTTP request using Angular's HttpClient.\n   *\n   * @param config - Request configuration\n   * @returns Response with parsed data\n   * @throws NAuthClientError if request fails\n   */\n  async request<T>(config: HttpRequest): Promise<HttpResponse<T>> {\n    try {\n      // Use Angular's HttpClient - goes through ALL interceptors.\n      // IMPORTANT: Use responseType 'text' to avoid raw JSON.parse crashes when\n      // the backend returns HTML (seen in some proxy/SSR/misroute setups).\n      const res = await firstValueFrom(\n        this.http.request(config.method, config.url, {\n          body: config.body,\n          headers: config.headers,\n          withCredentials: config.credentials === 'include',\n          observe: 'response',\n          responseType: 'text',\n        }),\n      );\n\n      const contentType = res.headers?.get('content-type');\n      const parsed = this.parseJsonBody(res.body ?? '', contentType);\n\n      return {\n        data: parsed as T,\n        status: res.status,\n        headers: {}, // Reserved for future header passthrough if needed\n      };\n    } catch (error) {\n      if (error instanceof HttpErrorResponse) {\n        // Convert Angular's HttpErrorResponse to NAuthClientError.\n        // When using responseType 'text', `error.error` is typically a string.\n        const contentType = error.headers?.get('content-type') ?? null;\n        const rawBody = typeof error.error === 'string' ? error.error : '';\n        const parsedError = this.parseJsonBody(rawBody, contentType);\n\n        const errorData =\n          typeof parsedError === 'object' && parsedError !== null ? (parsedError as Record<string, unknown>) : {};\n        const code =\n          typeof errorData['code'] === 'string' ? (errorData['code'] as NAuthErrorCode) : NAuthErrorCode.INTERNAL_ERROR;\n        const message =\n          typeof errorData['message'] === 'string'\n            ? (errorData['message'] as string)\n            : typeof parsedError === 'string' && parsedError.trim()\n              ? parsedError\n              : error.message || `Request failed with status ${error.status}`;\n        const timestamp = typeof errorData['timestamp'] === 'string' ? (errorData['timestamp'] as string) : undefined;\n        const details =\n          typeof errorData['details'] === 'object' ? (errorData['details'] as Record<string, unknown>) : undefined;\n\n        throw new NAuthClientError(code, message, {\n          statusCode: error.status,\n          timestamp,\n          details,\n          isNetworkError: error.status === 0, // Network error (no response from server)\n        });\n      }\n\n      // Re-throw non-HTTP errors as an SDK error so consumers don't see raw parser crashes.\n      const message = error instanceof Error ? error.message : 'Unknown error';\n      throw new NAuthClientError(NAuthErrorCode.INTERNAL_ERROR, message, {\n        statusCode: 0,\n        isNetworkError: true,\n      });\n    }\n  }\n}\n"]}

package/esm2022/standalone/http-adapter.mjs

@@ -29,6 +29,37 @@ export class AngularHttpAdapter {
     constructor(http) {
         this.http = http;
     }
+    /**
+     * Safely parse a JSON response body.
+     *
+     * Angular's fetch backend (`withFetch()`) will throw a raw `SyntaxError` if
+     * `responseType: 'json'` is used and the backend returns HTML (common for
+     * proxies, 502 pages, SSR fallbacks, or misrouted requests).
+     *
+     * To avoid crashing consumer apps, we always request as text and then parse
+     * JSON only when the response actually looks like JSON.
+     *
+     * @param bodyText - Raw response body as text
+     * @param contentType - Content-Type header value (if available)
+     * @returns Parsed JSON value (unknown)
+     * @throws {SyntaxError} When body is non-empty but not valid JSON
+     */
+    parseJsonBody(bodyText, contentType) {
+        const trimmed = bodyText.trim();
+        if (!trimmed)
+            return null;
+        // If it's clearly HTML, never attempt JSON.parse (some proxies mislabel Content-Type).
+        if (trimmed.startsWith('<')) {
+            return bodyText;
+        }
+        const looksLikeJson = trimmed.startsWith('{') || trimmed.startsWith('[');
+        const isJsonContentType = typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');
+        if (!looksLikeJson && !isJsonContentType) {
+            // Return raw text when it doesn't look like JSON (e.g., HTML error pages).
+            return bodyText;
+        }
+        return JSON.parse(trimmed);
+    }
     /**
      * Execute HTTP request using Angular's HttpClient.
      *
@@ -38,29 +69,40 @@ export class AngularHttpAdapter {
      */
     async request(config) {
         try {
-            // Use Angular's HttpClient - goes through ALL interceptors
-            const data = await firstValueFrom(this.http.request(config.method, config.url, {
+            // Use Angular's HttpClient - goes through ALL interceptors.
+            // IMPORTANT: Use responseType 'text' to avoid raw JSON.parse crashes when
+            // the backend returns HTML (seen in some proxy/SSR/misroute setups).
+            const res = await firstValueFrom(this.http.request(config.method, config.url, {
                 body: config.body,
                 headers: config.headers,
                 withCredentials: config.credentials === 'include',
-                observe: 'body', // Only return body data
+                observe: 'response',
+                responseType: 'text',
             }));
+            const contentType = res.headers?.get('content-type');
+            const parsed = this.parseJsonBody(res.body ?? '', contentType);
             return {
-                data,
-                status: 200, // HttpClient only returns data on success
-                headers: {}, // Can extract from observe: 'response' if needed
+                data: parsed,
+                status: res.status,
+                headers: {}, // Reserved for future header passthrough if needed
             };
         }
         catch (error) {
             if (error instanceof HttpErrorResponse) {
-                // Convert Angular's HttpErrorResponse to NAuthClientError
-                const errorData = error.error || {};
-                const code = typeof errorData['code'] === 'string' ? errorData.code : NAuthErrorCode.INTERNAL_ERROR;
+                // Convert Angular's HttpErrorResponse to NAuthClientError.
+                // When using responseType 'text', `error.error` is typically a string.
+                const contentType = error.headers?.get('content-type') ?? null;
+                const rawBody = typeof error.error === 'string' ? error.error : '';
+                const parsedError = this.parseJsonBody(rawBody, contentType);
+                const errorData = typeof parsedError === 'object' && parsedError !== null ? parsedError : {};
+                const code = typeof errorData['code'] === 'string' ? errorData['code'] : NAuthErrorCode.INTERNAL_ERROR;
                 const message = typeof errorData['message'] === 'string'
-                    ? errorData.message
-                    : error.message || `Request failed with status ${error.status}`;
-                const timestamp = typeof errorData['timestamp'] === 'string' ? errorData.timestamp : undefined;
-                const details = errorData['details'];
+                    ? errorData['message']
+                    : typeof parsedError === 'string' && parsedError.trim()
+                        ? parsedError
+                        : error.message || `Request failed with status ${error.status}`;
+                const timestamp = typeof errorData['timestamp'] === 'string' ? errorData['timestamp'] : undefined;
+                const details = typeof errorData['details'] === 'object' ? errorData['details'] : undefined;
                 throw new NAuthClientError(code, message, {
                     statusCode: error.status,
                     timestamp,
@@ -68,8 +110,12 @@ export class AngularHttpAdapter {
                     isNetworkError: error.status === 0, // Network error (no response from server)
                 });
             }
-            // Re-throw non-HTTP errors
-            throw error;
+            // Re-throw non-HTTP errors as an SDK error so consumers don't see raw parser crashes.
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new NAuthClientError(NAuthErrorCode.INTERNAL_ERROR, message, {
+                statusCode: 0,
+                isNetworkError: true,
+            });
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularHttpAdapter, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -78,4 +124,4 @@ export class AngularHttpAdapter {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularHttpAdapter, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-adapter.js","sourceRoot":"","sources":["../../../standalone/http-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\nimport { HttpAdapter, HttpRequest, HttpResponse, NAuthClientError, NAuthErrorCode } from '@nauth-toolkit/client';\n\n/**\n * HTTP adapter for Angular using HttpClient.\n *\n * This adapter:\n * - Uses Angular's HttpClient for all requests\n * - Works with Angular's HTTP interceptors (including authInterceptor)\n * - Auto-provided via Angular DI (providedIn: 'root')\n * - Converts HttpClient responses to HttpResponse format\n * - Converts HttpErrorResponse to NAuthClientError\n *\n * Users don't need to configure this manually - it's automatically\n * injected when using AuthService in Angular apps.\n *\n * @example\n * ```typescript\n * // Automatic usage (no manual setup needed)\n * // AuthService automatically injects AngularHttpAdapter\n * constructor(private auth: AuthService) {}\n * ```\n */\n@Injectable()\nexport class AngularHttpAdapter implements HttpAdapter {\n  constructor(private readonly http: HttpClient) {}\n\n  /**\n   * Safely parse a JSON response body.\n   *\n   * Angular's fetch backend (`withFetch()`) will throw a raw `SyntaxError` if\n   * `responseType: 'json'` is used and the backend returns HTML (common for\n   * proxies, 502 pages, SSR fallbacks, or misrouted requests).\n   *\n   * To avoid crashing consumer apps, we always request as text and then parse\n   * JSON only when the response actually looks like JSON.\n   *\n   * @param bodyText - Raw response body as text\n   * @param contentType - Content-Type header value (if available)\n   * @returns Parsed JSON value (unknown)\n   * @throws {SyntaxError} When body is non-empty but not valid JSON\n   */\n  private parseJsonBody(bodyText: string, contentType: string | null): unknown {\n    const trimmed = bodyText.trim();\n    if (!trimmed) return null;\n\n    // If it's clearly HTML, never attempt JSON.parse (some proxies mislabel Content-Type).\n    if (trimmed.startsWith('<')) {\n      return bodyText;\n    }\n\n    const looksLikeJson = trimmed.startsWith('{') || trimmed.startsWith('[');\n    const isJsonContentType = typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');\n\n    if (!looksLikeJson && !isJsonContentType) {\n      // Return raw text when it doesn't look like JSON (e.g., HTML error pages).\n      return bodyText;\n    }\n\n    return JSON.parse(trimmed) as unknown;\n  }\n\n  /**\n   * Execute HTTP request using Angular's HttpClient.\n   *\n   * @param config - Request configuration\n   * @returns Response with parsed data\n   * @throws NAuthClientError if request fails\n   */\n  async request<T>(config: HttpRequest): Promise<HttpResponse<T>> {\n    try {\n      // Use Angular's HttpClient - goes through ALL interceptors.\n      // IMPORTANT: Use responseType 'text' to avoid raw JSON.parse crashes when\n      // the backend returns HTML (seen in some proxy/SSR/misroute setups).\n      const res = await firstValueFrom(\n        this.http.request(config.method, config.url, {\n          body: config.body,\n          headers: config.headers,\n          withCredentials: config.credentials === 'include',\n          observe: 'response',\n          responseType: 'text',\n        }),\n      );\n\n      const contentType = res.headers?.get('content-type');\n      const parsed = this.parseJsonBody(res.body ?? '', contentType);\n\n      return {\n        data: parsed as T,\n        status: res.status,\n        headers: {}, // Reserved for future header passthrough if needed\n      };\n    } catch (error) {\n      if (error instanceof HttpErrorResponse) {\n        // Convert Angular's HttpErrorResponse to NAuthClientError.\n        // When using responseType 'text', `error.error` is typically a string.\n        const contentType = error.headers?.get('content-type') ?? null;\n        const rawBody = typeof error.error === 'string' ? error.error : '';\n        const parsedError = this.parseJsonBody(rawBody, contentType);\n\n        const errorData = typeof parsedError === 'object' && parsedError !== null ? (parsedError as Record<string, unknown>) : {};\n        const code = typeof errorData['code'] === 'string' ? (errorData['code'] as NAuthErrorCode) : NAuthErrorCode.INTERNAL_ERROR;\n        const message =\n          typeof errorData['message'] === 'string'\n            ? (errorData['message'] as string)\n            : typeof parsedError === 'string' && parsedError.trim()\n              ? parsedError\n              : error.message || `Request failed with status ${error.status}`;\n        const timestamp = typeof errorData['timestamp'] === 'string' ? (errorData['timestamp'] as string) : undefined;\n        const details = typeof errorData['details'] === 'object' ? (errorData['details'] as Record<string, unknown>) : undefined;\n\n        throw new NAuthClientError(code, message, {\n          statusCode: error.status,\n          timestamp,\n          details,\n          isNetworkError: error.status === 0, // Network error (no response from server)\n        });\n      }\n\n      // Re-throw non-HTTP errors as an SDK error so consumers don't see raw parser crashes.\n      const message = error instanceof Error ? error.message : 'Unknown error';\n      throw new NAuthClientError(NAuthErrorCode.INTERNAL_ERROR, message, {\n        statusCode: 0,\n        isNetworkError: true,\n      });\n    }\n  }\n}\n"]}

package/fesm2022/nauth-toolkit-client-angular-standalone.mjs

@@ -39,6 +39,37 @@ class AngularHttpAdapter {
     constructor(http) {
         this.http = http;
     }
+    /**
+     * Safely parse a JSON response body.
+     *
+     * Angular's fetch backend (`withFetch()`) will throw a raw `SyntaxError` if
+     * `responseType: 'json'` is used and the backend returns HTML (common for
+     * proxies, 502 pages, SSR fallbacks, or misrouted requests).
+     *
+     * To avoid crashing consumer apps, we always request as text and then parse
+     * JSON only when the response actually looks like JSON.
+     *
+     * @param bodyText - Raw response body as text
+     * @param contentType - Content-Type header value (if available)
+     * @returns Parsed JSON value (unknown)
+     * @throws {SyntaxError} When body is non-empty but not valid JSON
+     */
+    parseJsonBody(bodyText, contentType) {
+        const trimmed = bodyText.trim();
+        if (!trimmed)
+            return null;
+        // If it's clearly HTML, never attempt JSON.parse (some proxies mislabel Content-Type).
+        if (trimmed.startsWith('<')) {
+            return bodyText;
+        }
+        const looksLikeJson = trimmed.startsWith('{') || trimmed.startsWith('[');
+        const isJsonContentType = typeof contentType === 'string' && contentType.toLowerCase().includes('application/json');
+        if (!looksLikeJson && !isJsonContentType) {
+            // Return raw text when it doesn't look like JSON (e.g., HTML error pages).
+            return bodyText;
+        }
+        return JSON.parse(trimmed);
+    }
     /**
      * Execute HTTP request using Angular's HttpClient.
      *
@@ -48,29 +79,40 @@ class AngularHttpAdapter {
      */
     async request(config) {
         try {
-            // Use Angular's HttpClient - goes through ALL interceptors
-            const data = await firstValueFrom(this.http.request(config.method, config.url, {
+            // Use Angular's HttpClient - goes through ALL interceptors.
+            // IMPORTANT: Use responseType 'text' to avoid raw JSON.parse crashes when
+            // the backend returns HTML (seen in some proxy/SSR/misroute setups).
+            const res = await firstValueFrom(this.http.request(config.method, config.url, {
                 body: config.body,
                 headers: config.headers,
                 withCredentials: config.credentials === 'include',
-                observe: 'body', // Only return body data
+                observe: 'response',
+                responseType: 'text',
             }));
+            const contentType = res.headers?.get('content-type');
+            const parsed = this.parseJsonBody(res.body ?? '', contentType);
             return {
-                data,
-                status: 200, // HttpClient only returns data on success
-                headers: {}, // Can extract from observe: 'response' if needed
+                data: parsed,
+                status: res.status,
+                headers: {}, // Reserved for future header passthrough if needed
             };
         }
         catch (error) {
             if (error instanceof HttpErrorResponse) {
-                // Convert Angular's HttpErrorResponse to NAuthClientError
-                const errorData = error.error || {};
-                const code = typeof errorData['code'] === 'string' ? errorData.code : NAuthErrorCode.INTERNAL_ERROR;
+                // Convert Angular's HttpErrorResponse to NAuthClientError.
+                // When using responseType 'text', `error.error` is typically a string.
+                const contentType = error.headers?.get('content-type') ?? null;
+                const rawBody = typeof error.error === 'string' ? error.error : '';
+                const parsedError = this.parseJsonBody(rawBody, contentType);
+                const errorData = typeof parsedError === 'object' && parsedError !== null ? parsedError : {};
+                const code = typeof errorData['code'] === 'string' ? errorData['code'] : NAuthErrorCode.INTERNAL_ERROR;
                 const message = typeof errorData['message'] === 'string'
-                    ? errorData.message
-                    : error.message || `Request failed with status ${error.status}`;
-                const timestamp = typeof errorData['timestamp'] === 'string' ? errorData.timestamp : undefined;
-                const details = errorData['details'];
+                    ? errorData['message']
+                    : typeof parsedError === 'string' && parsedError.trim()
+                        ? parsedError
+                        : error.message || `Request failed with status ${error.status}`;
+                const timestamp = typeof errorData['timestamp'] === 'string' ? errorData['timestamp'] : undefined;
+                const details = typeof errorData['details'] === 'object' ? errorData['details'] : undefined;
                 throw new NAuthClientError(code, message, {
                     statusCode: error.status,
                     timestamp,
@@ -78,8 +120,12 @@ class AngularHttpAdapter {
                     isNetworkError: error.status === 0, // Network error (no response from server)
                 });
             }
-            // Re-throw non-HTTP errors
-            throw error;
+            // Re-throw non-HTTP errors as an SDK error so consumers don't see raw parser crashes.
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            throw new NAuthClientError(NAuthErrorCode.INTERNAL_ERROR, message, {
+                statusCode: 0,
+                isNetworkError: true,
+            });
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularHttpAdapter, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });