@naturalcycles/js-lib 14.241.3 → 14.242.0

package/dist/error/assert.d.ts

@@ -8,12 +8,13 @@ import { Class } from '..';
  * vice-versa - for completely unexpected and 100% buggy "should never happen" cases.
  *
  * It'll result in http 500 on the server (cause that's the right code for "unexpected" errors).
- * Pass { httpStatusCode: x } at errorData argument to override the http code (will be picked up by backend-lib).
+ * Pass { backendResponseStatusCode: x } at errorData argument to override the http code (will be picked up by backend-lib).
  *
  * API is similar to Node's assert(), except:
  * 1. Throws js-lib's AppError
  * 2. Has a default message, if not provided
- * 3. Sets `userFriendly` flag to true, cause it's always better to have at least SOME clue, rather than fully generic "Oops" error.
+ *
+ * Since 2024-07-10 it no longer sets `userFriendly: true` by default.
  */
 export declare function _assert(condition: any, // will be evaluated as Boolean
 message?: string, errorData?: ErrorData): asserts condition;

package/dist/error/assert.js

@@ -18,18 +18,18 @@ const __1 = require("..");
  * vice-versa - for completely unexpected and 100% buggy "should never happen" cases.
  *
  * It'll result in http 500 on the server (cause that's the right code for "unexpected" errors).
- * Pass { httpStatusCode: x } at errorData argument to override the http code (will be picked up by backend-lib).
+ * Pass { backendResponseStatusCode: x } at errorData argument to override the http code (will be picked up by backend-lib).
  *
  * API is similar to Node's assert(), except:
  * 1. Throws js-lib's AppError
  * 2. Has a default message, if not provided
- * 3. Sets `userFriendly` flag to true, cause it's always better to have at least SOME clue, rather than fully generic "Oops" error.
+ *
+ * Since 2024-07-10 it no longer sets `userFriendly: true` by default.
  */
 function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
         throw new __1.AssertionError(message || 'condition failed', {
-            userFriendly: true,
             ...errorData,
         });
     }
@@ -47,7 +47,6 @@ function _assertEquals(actual, expected, message, errorData) {
                 .filter(Boolean)
                 .join('\n');
         throw new __1.AssertionError(msg, {
-            userFriendly: true,
             ...errorData,
         });
     }
@@ -65,16 +64,13 @@ function _assertDeepEquals(actual, expected, message, errorData) {
                 .filter(Boolean)
                 .join('\n');
         throw new __1.AssertionError(msg, {
-            userFriendly: true,
             ...errorData,
         });
     }
 }
 function _assertIsError(err, errorClass = Error) {
     if (!(err instanceof errorClass)) {
-        throw new __1.AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`, {
-            userFriendly: true,
-        });
+        throw new __1.AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`);
     }
 }
 /**
@@ -90,9 +86,7 @@ function _assertErrorClassOrRethrow(err, errorClass) {
 }
 function _assertIsErrorObject(obj) {
     if (!(0, __1._isErrorObject)(obj)) {
-        throw new __1.AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`, {
-            userFriendly: true,
-        });
+        throw new __1.AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
     }
 }
 function _assertIsString(v, message) {
@@ -104,8 +98,6 @@ function _assertIsNumber(v, message) {
 function _assertTypeOf(v, expectedType, message) {
     if (typeof v !== expectedType) {
         const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`;
-        throw new __1.AssertionError(msg, {
-            userFriendly: true,
-        });
+        throw new __1.AssertionError(msg);
     }
 }

package/dist/error/error.model.d.ts

@@ -10,7 +10,12 @@ export interface ErrorData {
      */
     code?: string;
     /**
-     * If error.message is user-friendly (can be shown to the user "as is")
+     * If error.message is user-friendly (can be shown to the user "as is").
+     *
+     * This is a hint to the Client on how it should render the error message.
+     * userFriendly true means it can be rendered "as is".
+     * userFriendly false (or undefined) means the message is not guaranteed to be user-friendly,
+     * so client can resort to more generic "Oops, something went wrong" message.
      */
     userFriendly?: boolean;
     /**

package/dist/error/error.util.d.ts

@@ -50,7 +50,7 @@ export declare function _isErrorLike(o: any): o is ErrorLike;
  *
  * try {} catch (err) {
  *   throw _errorDataAppend(err, {
- *     httpStatusCode: 401,
+ *     backendResponseStatusCode: 401,
  *   })
  * }
  */

package/dist/error/error.util.js

@@ -212,7 +212,7 @@ function _isErrorLike(o) {
  *
  * try {} catch (err) {
  *   throw _errorDataAppend(err, {
- *     httpStatusCode: 401,
+ *     backendResponseStatusCode: 401,
  *   })
  * }
  */

package/dist/http/fetcher.js

@@ -339,7 +339,7 @@ class Fetcher {
         };
         let responseStatusCode = res.fetchResponse?.status || 0;
         if (res.statusFamily === 2) {
-            // important to reset httpStatusCode to 0 in this case, as status 2xx can be misleading
+            // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading
             res.statusFamily = undefined;
             res.statusCode = undefined;
             responseStatusCode = 0;

package/dist/semver.js

@@ -64,7 +64,6 @@ class SemverFactory {
     of(input) {
         const s = this.parseOrNull(input);
         (0, assert_1._assert)(s !== null, `Cannot parse "${input}" into Semver`, {
-            userFriendly: true,
             input,
         });
         return s;

package/dist/string/stringify.js

@@ -71,7 +71,7 @@ function _stringify(obj, opt = {}) {
         // }
         // if (_isErrorObject(obj) && _isHttpErrorObject(obj)) {
         //   // Printing (0) to avoid ambiguity
-        //   s = `${obj.name}(${obj.data.httpStatusCode}): ${obj.message}`
+        //   s = `${obj.name}(${obj.data.backendResponseStatusCode}): ${obj.message}`
         // }
         s = [obj.name, obj.message].filter(Boolean).join(': ');
         if (typeof obj.code === 'string') {

package/dist-esm/error/assert.js

@@ -7,18 +7,18 @@ import { _deepEquals, _isErrorObject, _stringify, AssertionError } from '..';
  * vice-versa - for completely unexpected and 100% buggy "should never happen" cases.
  *
  * It'll result in http 500 on the server (cause that's the right code for "unexpected" errors).
- * Pass { httpStatusCode: x } at errorData argument to override the http code (will be picked up by backend-lib).
+ * Pass { backendResponseStatusCode: x } at errorData argument to override the http code (will be picked up by backend-lib).
  *
  * API is similar to Node's assert(), except:
  * 1. Throws js-lib's AppError
  * 2. Has a default message, if not provided
- * 3. Sets `userFriendly` flag to true, cause it's always better to have at least SOME clue, rather than fully generic "Oops" error.
+ *
+ * Since 2024-07-10 it no longer sets `userFriendly: true` by default.
  */
 export function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
         throw new AssertionError(message || 'condition failed', {
-            userFriendly: true,
             ...errorData,
         });
     }
@@ -36,7 +36,6 @@ export function _assertEquals(actual, expected, message, errorData) {
                 .filter(Boolean)
                 .join('\n');
         throw new AssertionError(msg, {
-            userFriendly: true,
             ...errorData,
         });
     }
@@ -54,16 +53,13 @@ export function _assertDeepEquals(actual, expected, message, errorData) {
                 .filter(Boolean)
                 .join('\n');
         throw new AssertionError(msg, {
-            userFriendly: true,
             ...errorData,
         });
     }
 }
 export function _assertIsError(err, errorClass = Error) {
     if (!(err instanceof errorClass)) {
-        throw new AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`, {
-            userFriendly: true,
-        });
+        throw new AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`);
     }
 }
 /**
@@ -79,9 +75,7 @@ export function _assertErrorClassOrRethrow(err, errorClass) {
 }
 export function _assertIsErrorObject(obj) {
     if (!_isErrorObject(obj)) {
-        throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`, {
-            userFriendly: true,
-        });
+        throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
     }
 }
 export function _assertIsString(v, message) {
@@ -93,8 +87,6 @@ export function _assertIsNumber(v, message) {
 export function _assertTypeOf(v, expectedType, message) {
     if (typeof v !== expectedType) {
         const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`;
-        throw new AssertionError(msg, {
-            userFriendly: true,
-        });
+        throw new AssertionError(msg);
     }
 }

package/dist-esm/error/error.util.js

@@ -199,7 +199,7 @@ export function _isErrorLike(o) {
  *
  * try {} catch (err) {
  *   throw _errorDataAppend(err, {
- *     httpStatusCode: 401,
+ *     backendResponseStatusCode: 401,
  *   })
  * }
  */

package/dist-esm/http/fetcher.js

@@ -331,7 +331,7 @@ export class Fetcher {
         });
         let responseStatusCode = res.fetchResponse?.status || 0;
         if (res.statusFamily === 2) {
-            // important to reset httpStatusCode to 0 in this case, as status 2xx can be misleading
+            // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading
             res.statusFamily = undefined;
             res.statusCode = undefined;
             responseStatusCode = 0;

package/dist-esm/semver.js

@@ -59,7 +59,6 @@ class SemverFactory {
     of(input) {
         const s = this.parseOrNull(input);
         _assert(s !== null, `Cannot parse "${input}" into Semver`, {
-            userFriendly: true,
             input,
         });
         return s;

package/dist-esm/string/stringify.js

@@ -67,7 +67,7 @@ export function _stringify(obj, opt = {}) {
         // }
         // if (_isErrorObject(obj) && _isHttpErrorObject(obj)) {
         //   // Printing (0) to avoid ambiguity
-        //   s = `${obj.name}(${obj.data.httpStatusCode}): ${obj.message}`
+        //   s = `${obj.name}(${obj.data.backendResponseStatusCode}): ${obj.message}`
         // }
         s = [obj.name, obj.message].filter(Boolean).join(': ');
         if (typeof obj.code === 'string') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.241.3",
+  "version": "14.242.0",
   "scripts": {
     "prepare": "husky",
     "build-prod": "build-prod-esm-cjs",

package/src/error/assert.ts

@@ -9,12 +9,13 @@ import { _deepEquals, _isErrorObject, _stringify, AssertionError, Class } from '
  * vice-versa - for completely unexpected and 100% buggy "should never happen" cases.
  *
  * It'll result in http 500 on the server (cause that's the right code for "unexpected" errors).
- * Pass { httpStatusCode: x } at errorData argument to override the http code (will be picked up by backend-lib).
+ * Pass { backendResponseStatusCode: x } at errorData argument to override the http code (will be picked up by backend-lib).
  *
  * API is similar to Node's assert(), except:
  * 1. Throws js-lib's AppError
  * 2. Has a default message, if not provided
- * 3. Sets `userFriendly` flag to true, cause it's always better to have at least SOME clue, rather than fully generic "Oops" error.
+ *
+ * Since 2024-07-10 it no longer sets `userFriendly: true` by default.
  */
 export function _assert(
   condition: any, // will be evaluated as Boolean
@@ -23,7 +24,6 @@ export function _assert(
 ): asserts condition {
   if (!condition) {
     throw new AssertionError(message || 'condition failed', {
-      userFriendly: true,
       ...errorData,
     })
   }
@@ -49,7 +49,6 @@ export function _assertEquals<T>(
         .join('\n')
 
     throw new AssertionError(msg, {
-      userFriendly: true,
       ...errorData,
     })
   }
@@ -75,7 +74,6 @@ export function _assertDeepEquals<T>(
         .join('\n')
 
     throw new AssertionError(msg, {
-      userFriendly: true,
       ...errorData,
     })
   }
@@ -88,9 +86,6 @@ export function _assertIsError<ERR extends Error = Error>(
   if (!(err instanceof errorClass)) {
     throw new AssertionError(
       `Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`,
-      {
-        userFriendly: true,
-      },
     )
   }
 }
@@ -114,9 +109,7 @@ export function _assertIsErrorObject<DATA_TYPE extends ErrorData = ErrorData>(
   obj: any,
 ): asserts obj is ErrorObject<DATA_TYPE> {
   if (!_isErrorObject(obj)) {
-    throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`, {
-      userFriendly: true,
-    })
+    throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`)
   }
 }
 
@@ -131,8 +124,6 @@ export function _assertIsNumber(v: any, message?: string): asserts v is number {
 export function _assertTypeOf<T>(v: any, expectedType: string, message?: string): asserts v is T {
   if (typeof v !== expectedType) {
     const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`
-    throw new AssertionError(msg, {
-      userFriendly: true,
-    })
+    throw new AssertionError(msg)
   }
 }

package/src/error/error.model.ts

@@ -12,7 +12,12 @@ export interface ErrorData {
   code?: string
 
   /**
-   * If error.message is user-friendly (can be shown to the user "as is")
+   * If error.message is user-friendly (can be shown to the user "as is").
+   *
+   * This is a hint to the Client on how it should render the error message.
+   * userFriendly true means it can be rendered "as is".
+   * userFriendly false (or undefined) means the message is not guaranteed to be user-friendly,
+   * so client can resort to more generic "Oops, something went wrong" message.
    */
   userFriendly?: boolean
 

package/src/error/error.util.ts

@@ -259,7 +259,7 @@ export function _isErrorLike(o: any): o is ErrorLike {
  *
  * try {} catch (err) {
  *   throw _errorDataAppend(err, {
- *     httpStatusCode: 401,
+ *     backendResponseStatusCode: 401,
  *   })
  * }
  */

package/src/http/fetcher.ts

@@ -436,7 +436,7 @@ export class Fetcher {
 
     let responseStatusCode = res.fetchResponse?.status || 0
     if (res.statusFamily === 2) {
-      // important to reset httpStatusCode to 0 in this case, as status 2xx can be misleading
+      // important to reset responseStatusCode to 0 in this case, as status 2xx can be misleading
       res.statusFamily = undefined
       res.statusCode = undefined
       responseStatusCode = 0

package/src/semver.ts

@@ -68,7 +68,6 @@ class SemverFactory {
     const s = this.parseOrNull(input)
 
     _assert(s !== null, `Cannot parse "${input}" into Semver`, {
-      userFriendly: true,
       input,
     })
 

package/src/string/stringify.ts

@@ -112,7 +112,7 @@ export function _stringify(obj: any, opt: StringifyOptions = {}): string {
     // }
     // if (_isErrorObject(obj) && _isHttpErrorObject(obj)) {
     //   // Printing (0) to avoid ambiguity
-    //   s = `${obj.name}(${obj.data.httpStatusCode}): ${obj.message}`
+    //   s = `${obj.name}(${obj.data.backendResponseStatusCode}): ${obj.message}`
     // }
 
     s = [obj.name, obj.message].filter(Boolean).join(': ')