@naturalcycles/js-lib 14.133.0 → 14.134.0

package/dist/error/app.error.d.ts

@@ -14,5 +14,5 @@ export declare class AppError<DATA_TYPE extends ErrorData = ErrorData> extends E
      * cause here is normalized to be instance of Error
      */
     cause?: Error;
-    constructor(message: string, data?: DATA_TYPE, opt?: ErrorOptions);
+    constructor(message: string, data?: DATA_TYPE, opt?: ErrorOptions, name?: string);
 }

package/dist/error/app.error.js

@@ -11,11 +11,18 @@ exports.AppError = void 0;
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 class AppError extends Error {
-    constructor(message, data = {}, opt) {
+    constructor(message, data = {}, opt, name) {
         super(message);
         Object.defineProperty(this, 'name', {
-            value: this.constructor.name,
+            value: name || this.constructor.name,
             configurable: true,
+            writable: true,
+        });
+        // this is to allow changing this.constuctor.name to a non-minified version
+        Object.defineProperty(this.constructor, 'name', {
+            value: name || this.constructor.name,
+            configurable: true,
+            writable: true,
         });
         Object.defineProperty(this, 'data', {
             value: data,

package/dist/error/assert.d.ts

@@ -36,4 +36,5 @@ export declare function _assertIsString(v: any, message?: string): asserts v is
 export declare function _assertIsNumber(v: any, message?: string): asserts v is number;
 export declare function _assertTypeOf<T>(v: any, expectedType: string, message?: string): asserts v is T;
 export declare class AssertionError extends AppError {
+    constructor(message: string, data?: {}, opt?: ErrorOptions);
 }

package/dist/error/assert.js

@@ -103,5 +103,8 @@ function _assertTypeOf(v, expectedType, message) {
 }
 exports._assertTypeOf = _assertTypeOf;
 class AssertionError extends app_error_1.AppError {
+    constructor(message, data = {}, opt) {
+        super(message, data, opt, 'AssertionError');
+    }
 }
 exports.AssertionError = AssertionError;

package/dist/error/error.util.js

@@ -88,6 +88,12 @@ function _errorObjectToError(o, errorClass = Error) {
     Object.defineProperty(err, 'name', {
         value: o.name,
         configurable: true,
+        writable: true,
+    });
+    Object.defineProperty(err.constructor, 'name', {
+        value: o.name,
+        configurable: true,
+        writable: true,
     });
     Object.defineProperty(err, 'data', {
         value: o.data,

package/dist/error/http.error.js

@@ -7,7 +7,7 @@ const app_error_1 = require("./app.error");
  */
 class HttpError extends app_error_1.AppError {
     constructor(message, data, opt) {
-        super(message, data, opt);
+        super(message, data, opt, 'HttpError');
     }
 }
 exports.HttpError = HttpError;

package/dist/http/fetcher.d.ts

@@ -42,6 +42,8 @@ export declare class Fetcher {
     /**
      * Default is yes,
      * unless there's reason not to (e.g method is POST).
+     *
+     * statusCode of 0 (or absense of it) will BE retried.
      */
     private shouldRetry;
     private getStatusFamily;

package/dist/http/fetcher.js

@@ -12,7 +12,7 @@ const time_util_1 = require("../time/time.util");
 const http_model_1 = require("./http.model");
 const defRetryOptions = {
     count: 2,
-    timeout: 500,
+    timeout: 1000,
     timeoutMax: 30000,
     timeoutMultiplier: 2,
 };
@@ -253,11 +253,14 @@ class Fetcher {
             return;
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = (0, number_util_1._clamp)(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        await (0, pDelay_1.pDelay)(retryStatus.retryTimeout);
+        const noise = Math.random() * 500;
+        await (0, pDelay_1.pDelay)(retryStatus.retryTimeout + noise);
     }
     /**
      * Default is yes,
      * unless there's reason not to (e.g method is POST).
+     *
+     * statusCode of 0 (or absense of it) will BE retried.
      */
     shouldRetry(res) {
         const { retryPost, retry4xx, retry5xx } = res.req;

package/dist/promise/pTimeout.d.ts

@@ -2,6 +2,7 @@ import { AppError } from '../error/app.error';
 import type { ErrorData } from '../error/error.model';
 import type { AnyAsyncFunction } from '../types';
 export declare class TimeoutError extends AppError {
+    constructor(message: string, data?: {}, opt?: ErrorOptions);
 }
 export interface PTimeoutOptions {
     /**

package/dist/promise/pTimeout.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pTimeout = exports.pTimeoutFn = exports.TimeoutError = void 0;
 const app_error_1 = require("../error/app.error");
 class TimeoutError extends app_error_1.AppError {
+    constructor(message, data = {}, opt) {
+        super(message, data, opt, 'TimeoutError');
+    }
 }
 exports.TimeoutError = TimeoutError;
 /**

package/dist/string/stringifyAny.js

@@ -81,6 +81,8 @@ function _stringifyAny(obj, opt = {}) {
         }
         if ((0, error_util_1._isErrorObject)(obj)) {
             if ((0, error_util_1._isHttpErrorObject)(obj)) {
+                // Only include (statusCode) if it's non-zero
+                // No: print (0), as it removes ambiguity
                 // `replace` here works ONCE, exactly as we need it
                 s = s.replace('HttpError', `HttpError(${obj.data.httpStatusCode})`);
             }

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

@@ -8,11 +8,18 @@
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 export class AppError extends Error {
-    constructor(message, data = {}, opt) {
+    constructor(message, data = {}, opt, name) {
         super(message);
         Object.defineProperty(this, 'name', {
-            value: this.constructor.name,
+            value: name || this.constructor.name,
             configurable: true,
+            writable: true,
+        });
+        // this is to allow changing this.constuctor.name to a non-minified version
+        Object.defineProperty(this.constructor, 'name', {
+            value: name || this.constructor.name,
+            configurable: true,
+            writable: true,
         });
         Object.defineProperty(this, 'data', {
             value: data,

package/dist-esm/error/assert.js

@@ -84,4 +84,7 @@ export function _assertTypeOf(v, expectedType, message) {
     }
 }
 export class AssertionError extends AppError {
+    constructor(message, data = {}, opt) {
+        super(message, data, opt, 'AssertionError');
+    }
 }

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

@@ -79,6 +79,12 @@ export function _errorObjectToError(o, errorClass = Error) {
     Object.defineProperty(err, 'name', {
         value: o.name,
         configurable: true,
+        writable: true,
+    });
+    Object.defineProperty(err.constructor, 'name', {
+        value: o.name,
+        configurable: true,
+        writable: true,
     });
     Object.defineProperty(err, 'data', {
         value: o.data,

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

@@ -4,6 +4,6 @@ import { AppError } from './app.error';
  */
 export class HttpError extends AppError {
     constructor(message, data, opt) {
-        super(message, data, opt);
+        super(message, data, opt, 'HttpError');
     }
 }

package/dist-esm/http/fetcher.js

@@ -10,7 +10,7 @@ import { _since } from '../time/time.util';
 import { HTTP_METHODS } from './http.model';
 const defRetryOptions = {
     count: 2,
-    timeout: 500,
+    timeout: 1000,
     timeoutMax: 30000,
     timeoutMultiplier: 2,
 };
@@ -291,11 +291,14 @@ export class Fetcher {
             return;
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        await pDelay(retryStatus.retryTimeout);
+        const noise = Math.random() * 500;
+        await pDelay(retryStatus.retryTimeout + noise);
     }
     /**
      * Default is yes,
      * unless there's reason not to (e.g method is POST).
+     *
+     * statusCode of 0 (or absense of it) will BE retried.
      */
     shouldRetry(res) {
         var _a;

package/dist-esm/promise/pTimeout.js

@@ -1,5 +1,8 @@
 import { AppError } from '../error/app.error';
 export class TimeoutError extends AppError {
+    constructor(message, data = {}, opt) {
+        super(message, data, opt, 'TimeoutError');
+    }
 }
 /**
  * Decorates a Function with a timeout.

package/dist-esm/string/stringifyAny.js

@@ -77,6 +77,8 @@ export function _stringifyAny(obj, opt = {}) {
         }
         if (_isErrorObject(obj)) {
             if (_isHttpErrorObject(obj)) {
+                // Only include (statusCode) if it's non-zero
+                // No: print (0), as it removes ambiguity
                 // `replace` here works ONCE, exactly as we need it
                 s = s.replace('HttpError', `HttpError(${obj.data.httpStatusCode})`);
             }

package/package.json

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

package/src/error/app.error.ts

@@ -17,12 +17,20 @@ export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
    */
   override cause?: Error
 
-  constructor(message: string, data = {} as DATA_TYPE, opt?: ErrorOptions) {
+  constructor(message: string, data = {} as DATA_TYPE, opt?: ErrorOptions, name?: string) {
     super(message)
 
     Object.defineProperty(this, 'name', {
-      value: this.constructor.name,
+      value: name || this.constructor.name,
       configurable: true,
+      writable: true,
+    })
+
+    // this is to allow changing this.constuctor.name to a non-minified version
+    Object.defineProperty(this.constructor, 'name', {
+      value: name || this.constructor.name,
+      configurable: true,
+      writable: true,
     })
 
     Object.defineProperty(this, 'data', {

package/src/error/assert.ts

@@ -123,4 +123,8 @@ export function _assertTypeOf<T>(v: any, expectedType: string, message?: string)
   }
 }
 
-export class AssertionError extends AppError {}
+export class AssertionError extends AppError {
+  constructor(message: string, data = {}, opt?: ErrorOptions) {
+    super(message, data, opt, 'AssertionError')
+  }
+}

package/src/error/error.util.ts

@@ -105,6 +105,13 @@ export function _errorObjectToError<DATA_TYPE extends ErrorData, ERROR_TYPE exte
   Object.defineProperty(err, 'name', {
     value: o.name,
     configurable: true,
+    writable: true,
+  })
+
+  Object.defineProperty(err.constructor, 'name', {
+    value: o.name,
+    configurable: true,
+    writable: true,
   })
 
   Object.defineProperty(err, 'data', {

package/src/error/http.error.ts

@@ -8,6 +8,6 @@ export class HttpError<
   DATA_TYPE extends HttpErrorData = HttpErrorData,
 > extends AppError<DATA_TYPE> {
   constructor(message: string, data: DATA_TYPE, opt?: ErrorOptions) {
-    super(message, data, opt)
+    super(message, data, opt, 'HttpError')
   }
 }

package/src/http/fetcher.ts

@@ -30,7 +30,7 @@ import type { HttpStatusFamily } from './http.model'
 
 const defRetryOptions: FetcherRetryOptions = {
   count: 2,
-  timeout: 500,
+  timeout: 1000,
   timeoutMax: 30_000,
   timeoutMultiplier: 2,
 }
@@ -336,12 +336,15 @@ export class Fetcher {
     retryStatus.retryAttempt++
     retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax)
 
-    await pDelay(retryStatus.retryTimeout)
+    const noise = Math.random() * 500
+    await pDelay(retryStatus.retryTimeout + noise)
   }
 
   /**
    * Default is yes,
    * unless there's reason not to (e.g method is POST).
+   *
+   * statusCode of 0 (or absense of it) will BE retried.
    */
   private shouldRetry(res: FetcherResponse): boolean {
     const { retryPost, retry4xx, retry5xx } = res.req

package/src/promise/pTimeout.ts

@@ -2,7 +2,11 @@ import { AppError } from '../error/app.error'
 import type { ErrorData } from '../error/error.model'
 import type { AnyAsyncFunction } from '../types'
 
-export class TimeoutError extends AppError {}
+export class TimeoutError extends AppError {
+  constructor(message: string, data = {}, opt?: ErrorOptions) {
+    super(message, data, opt, 'TimeoutError')
+  }
+}
 
 export interface PTimeoutOptions {
   /**

package/src/string/stringifyAny.ts

@@ -125,6 +125,8 @@ export function _stringifyAny(obj: any, opt: StringifyAnyOptions = {}): string {
 
     if (_isErrorObject(obj)) {
       if (_isHttpErrorObject(obj)) {
+        // Only include (statusCode) if it's non-zero
+        // No: print (0), as it removes ambiguity
         // `replace` here works ONCE, exactly as we need it
         s = s.replace('HttpError', `HttpError(${obj.data.httpStatusCode})`)
       }