@marianmeres/http-utils 1.12.0 → 1.13.0

package/dist/error.d.ts

@@ -90,4 +90,5 @@ export declare const HTTP_ERROR: {
     ServiceUnavailable: typeof ServiceUnavailable;
 };
 export declare const createHttpError: (code: number | string, message?: string | null, body?: string | null, cause?: any) => BadRequest | Unauthorized | Forbidden | NotFound | MethodNotAllowed | RequestTimeout | Conflict | Gone | UnprocessableContent | ImATeapot | InternalServerError | NotImplemented | BadGateway | ServiceUnavailable;
+export declare const getErrorMessage: (e: any, stripErrorPrefix?: boolean) => string;
 export {};

package/dist/index.cjs

@@ -241,6 +241,15 @@ const _wellKnownCtorMap = {
     '502': BadGateway,
     '503': ServiceUnavailable,
 };
+const _maybeJsonParse = (v) => {
+    if (typeof v === 'string') {
+        try {
+            v = JSON.parse(v);
+        }
+        catch (e) { }
+    }
+    return v;
+};
 const createHttpError = (code, message, 
 // arbitrary content, typically http response body which threw this error
 // (will be JSON.parse-d if the content is a valid json string)
@@ -253,21 +262,9 @@ cause) => {
     if (isNaN(code) || !(code >= 400 && code < 600))
         code = fallback.CODE;
     // opinionated convention
-    if (typeof body === 'string') {
-        // prettier-ignore
-        try {
-            body = JSON.parse(body);
-        }
-        catch (e) { }
-    }
+    body = _maybeJsonParse(body);
     // opinionated convention
-    if (typeof cause === 'string') {
-        // prettier-ignore
-        try {
-            cause = JSON.parse(cause);
-        }
-        catch (e) { }
-    }
+    cause = _maybeJsonParse(cause);
     // try to find the well known one, otherwise fallback to generic
     const ctor = _wellKnownCtorMap[`${code}`] ?? HttpError;
     //
@@ -280,6 +277,40 @@ cause) => {
     e.body = body;
     return e;
 };
+const getErrorMessage = (e, stripErrorPrefix = true) => {
+    if (!e)
+        return '';
+    // PROBLEM is that error may bubble from various sources which are not always under control
+    // and even if they were it still may not be trivial to keep similar structure on each error boundary...
+    // So, we'll just do what we can, it will not be perfect, but should handle most cases most of the time.
+    // Also, I'm relying on some of my own opinionated conventions as well...
+    const cause = _maybeJsonParse(e?.cause);
+    const body = _maybeJsonParse(e?.body);
+    let msg = 
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
+    // e.cause is the standard prop for error details, so should be considered as
+    // the most authoritative (if available)
+    // "code" and "message" are my own conventions
+    cause?.code ||
+        cause?.message ||
+        (typeof cause === 'string' ? cause : null) ||
+        // non-standard "body" is this package's HttpError prop
+        body?.error?.message ||
+        body?.message ||
+        (typeof body === 'string' ? body : null) ||
+        // the common message from Error ctor (e.g. "Foo" if new TypeError("Foo"))
+        e?.message ||
+        // the Error class name (e.g. TypeError)
+        e?.name ||
+        // this should handle (almost) everything else (mainly if e is not the Error instance)
+        e?.toString() ||
+        // very last fallback if `toString()` was not available (or returned empty)
+        'Unknown Error';
+    if (stripErrorPrefix) {
+        msg = msg.replace(/^[^:]*Error: /, '');
+    }
+    return msg;
+};
 
 const _fetchRaw = async ({ method, path, data = null, token = null, headers = null, signal = null, credentials, }) => {
     headers = Object.entries(headers || {}).reduce((m, [k, v]) => ({ ...m, [k.toLowerCase()]: v }), {});
@@ -405,3 +436,4 @@ exports.HTTP_ERROR = HTTP_ERROR;
 exports.HTTP_STATUS = HTTP_STATUS;
 exports.createHttpApi = createHttpApi;
 exports.createHttpError = createHttpError;
+exports.getErrorMessage = getErrorMessage;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { HTTP_STATUS } from './status.js';
-export { HTTP_ERROR, createHttpError } from './error.js';
+export { HTTP_ERROR, createHttpError, getErrorMessage } from './error.js';
 export { createHttpApi } from './api.js';

package/dist/index.js

@@ -239,6 +239,15 @@ const _wellKnownCtorMap = {
     '502': BadGateway,
     '503': ServiceUnavailable,
 };
+const _maybeJsonParse = (v) => {
+    if (typeof v === 'string') {
+        try {
+            v = JSON.parse(v);
+        }
+        catch (e) { }
+    }
+    return v;
+};
 const createHttpError = (code, message, 
 // arbitrary content, typically http response body which threw this error
 // (will be JSON.parse-d if the content is a valid json string)
@@ -251,21 +260,9 @@ cause) => {
     if (isNaN(code) || !(code >= 400 && code < 600))
         code = fallback.CODE;
     // opinionated convention
-    if (typeof body === 'string') {
-        // prettier-ignore
-        try {
-            body = JSON.parse(body);
-        }
-        catch (e) { }
-    }
+    body = _maybeJsonParse(body);
     // opinionated convention
-    if (typeof cause === 'string') {
-        // prettier-ignore
-        try {
-            cause = JSON.parse(cause);
-        }
-        catch (e) { }
-    }
+    cause = _maybeJsonParse(cause);
     // try to find the well known one, otherwise fallback to generic
     const ctor = _wellKnownCtorMap[`${code}`] ?? HttpError;
     //
@@ -278,6 +275,40 @@ cause) => {
     e.body = body;
     return e;
 };
+const getErrorMessage = (e, stripErrorPrefix = true) => {
+    if (!e)
+        return '';
+    // PROBLEM is that error may bubble from various sources which are not always under control
+    // and even if they were it still may not be trivial to keep similar structure on each error boundary...
+    // So, we'll just do what we can, it will not be perfect, but should handle most cases most of the time.
+    // Also, I'm relying on some of my own opinionated conventions as well...
+    const cause = _maybeJsonParse(e?.cause);
+    const body = _maybeJsonParse(e?.body);
+    let msg = 
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
+    // e.cause is the standard prop for error details, so should be considered as
+    // the most authoritative (if available)
+    // "code" and "message" are my own conventions
+    cause?.code ||
+        cause?.message ||
+        (typeof cause === 'string' ? cause : null) ||
+        // non-standard "body" is this package's HttpError prop
+        body?.error?.message ||
+        body?.message ||
+        (typeof body === 'string' ? body : null) ||
+        // the common message from Error ctor (e.g. "Foo" if new TypeError("Foo"))
+        e?.message ||
+        // the Error class name (e.g. TypeError)
+        e?.name ||
+        // this should handle (almost) everything else (mainly if e is not the Error instance)
+        e?.toString() ||
+        // very last fallback if `toString()` was not available (or returned empty)
+        'Unknown Error';
+    if (stripErrorPrefix) {
+        msg = msg.replace(/^[^:]*Error: /, '');
+    }
+    return msg;
+};
 
 const _fetchRaw = async ({ method, path, data = null, token = null, headers = null, signal = null, credentials, }) => {
     headers = Object.entries(headers || {}).reduce((m, [k, v]) => ({ ...m, [k.toLowerCase()]: v }), {});
@@ -399,4 +430,4 @@ function createHttpApi(base, defaults, factoryErrorMessageExtractor) {
 }
 createHttpApi.defaultErrorMessageExtractor = null;
 
-export { HTTP_ERROR, HTTP_STATUS, createHttpApi, createHttpError };
+export { HTTP_ERROR, HTTP_STATUS, createHttpApi, createHttpError, getErrorMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@marianmeres/http-utils",
-	"version": "1.12.0",
+	"version": "1.13.0",
 	"description": "Misc DRY http fetch related helpers",
 	"type": "module",
 	"main": "./dist/index.cjs",