@naturalcycles/js-lib 14.144.1 → 14.146.0

package/dist-esm/http/fetcher.js

@@ -1,5 +1,4 @@
 /// <reference lib="dom"/>
-import { __asyncValues } from "tslib";
 import { isServerSide } from '../env';
 import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util';
 import { HttpRequestError } from '../error/httpRequestError';
@@ -66,6 +65,16 @@ export class Fetcher {
     static create(cfg = {}) {
         return new Fetcher(cfg);
     }
+    // mode=readableStream
+    /**
+     * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>
+     *
+     * More on streams and Node interop:
+     * https://css-tricks.com/web-streams-everywhere-and-fetch-for-node-js/
+     */
+    async getReadableStream(url, opt) {
+        return await this.fetch(url, Object.assign({ mode: 'readableStream' }, opt));
+    }
     async fetch(url, opt) {
         const res = await this.doFetch(url, opt);
         if (res.err) {
@@ -80,11 +89,13 @@ export class Fetcher {
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
      */
-    async doFetch(url, rawOpt = {}) {
-        var _a, e_1, _b, _c, _d, e_2, _e, _f;
-        var _g;
+    async doFetch(url, opt = {}) {
+        const req = this.normalizeOptions(url, opt);
+        return await this.doFetchRequest(req);
+    }
+    async doFetchRequest(req) {
+        var _a;
         const { logger } = this.cfg;
-        const req = this.normalizeOptions(url, rawOpt);
         const { timeoutSeconds, init: { method }, } = req;
         // setup timeout
         let timeout;
@@ -95,25 +106,8 @@ export class Fetcher {
                 abortController.abort(`timeout of ${timeoutSeconds} sec`);
             }, timeoutSeconds * 1000);
         }
-        try {
-            for (var _h = true, _j = __asyncValues(this.cfg.hooks.beforeRequest || []), _k; _k = await _j.next(), _a = _k.done, !_a;) {
-                _c = _k.value;
-                _h = false;
-                try {
-                    const hook = _c;
-                    await hook(req);
-                }
-                finally {
-                    _h = true;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_h && !_a && (_b = _j.return)) await _b.call(_j);
-            }
-            finally { if (e_1) throw e_1.error; }
+        for (const hook of this.cfg.hooks.beforeRequest || []) {
+            await hook(req);
         }
         const isFullUrl = req.url.includes('://');
         const fullUrl = isFullUrl ? new URL(req.url) : undefined;
@@ -129,7 +123,7 @@ export class Fetcher {
             signature,
         };
         while (!res.retryStatus.retryStopped) {
-            const started = Date.now();
+            req.started = Date.now();
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
                 logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
@@ -151,37 +145,26 @@ export class Fetcher {
                 res.fetchResponse = undefined;
             }
             res.statusFamily = this.getStatusFamily(res);
-            if ((_g = res.fetchResponse) === null || _g === void 0 ? void 0 : _g.ok) {
-                await this.onOkResponse(res, started, timeout);
+            if ((_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.ok) {
+                await this.onOkResponse(res, timeout);
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, started, timeout);
+                await this.onNotOkResponse(res, timeout);
             }
         }
-        try {
-            for (var _l = true, _m = __asyncValues(this.cfg.hooks.afterResponse || []), _o; _o = await _m.next(), _d = _o.done, !_d;) {
-                _f = _o.value;
-                _l = false;
-                try {
-                    const hook = _f;
-                    await hook(res);
-                }
-                finally {
-                    _l = true;
-                }
-            }
+        for (const hook of this.cfg.hooks.afterResponse || []) {
+            await hook(res);
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (!_l && !_d && (_e = _m.return)) await _e.call(_m);
+        if (req.paginate && res.ok) {
+            const proceed = await req.paginate(req, res);
+            if (proceed) {
+                return await this.doFetchRequest(req);
             }
-            finally { if (e_2) throw e_2.error; }
         }
         return res;
     }
-    async onOkResponse(res, started, timeout) {
+    async onOkResponse(res, timeout) {
         const { req } = res;
         const { mode } = res.req;
         if (mode === 'json') {
@@ -204,7 +187,7 @@ export class Fetcher {
                         // } satisfies HttpRequestErrorData)
                         res.err = _anyToError(err);
                         res.ok = false;
-                        return await this.onNotOkResponse(res, started, timeout);
+                        return await this.onNotOkResponse(res, timeout);
                     }
                 }
                 else {
@@ -227,6 +210,14 @@ export class Fetcher {
         else if (mode === 'blob') {
             res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
         }
+        else if (mode === 'readableStream') {
+            res.body = res.fetchResponse.body;
+            if (res.body === null) {
+                res.err = new Error(`fetchResponse.body is null`);
+                res.ok = false;
+                return await this.onNotOkResponse(res, timeout);
+            }
+        }
         clearTimeout(timeout);
         res.retryStatus.retryStopped = true;
         // res.err can happen on JSON.parse error
@@ -238,7 +229,7 @@ export class Fetcher {
                 res.fetchResponse.status,
                 res.signature,
                 retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`,
-                _since(started),
+                _since(res.req.started),
             ]
                 .filter(Boolean)
                 .join(' '));
@@ -253,7 +244,7 @@ export class Fetcher {
     async callNativeFetch(url, init) {
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, started, timeout) {
+    async onNotOkResponse(res, timeout) {
         var _a, _b;
         clearTimeout(timeout);
         let cause;
@@ -280,35 +271,18 @@ export class Fetcher {
             requestBaseUrl: this.cfg.baseUrl || null,
             requestMethod: res.req.init.method,
             requestSignature: res.signature,
-            requestDuration: Date.now() - started,
+            requestDuration: Date.now() - res.req.started,
         }), cause);
         await this.processRetry(res);
     }
     async processRetry(res) {
-        var _a, e_3, _b, _c;
+        var _a;
         const { retryStatus } = res;
         if (!this.shouldRetry(res)) {
             retryStatus.retryStopped = true;
         }
-        try {
-            for (var _d = true, _e = __asyncValues(this.cfg.hooks.beforeRetry || []), _f; _f = await _e.next(), _a = _f.done, !_a;) {
-                _c = _f.value;
-                _d = false;
-                try {
-                    const hook = _c;
-                    await hook(res);
-                }
-                finally {
-                    _d = true;
-                }
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
-            }
-            finally { if (e_3) throw e_3.error; }
+        for (const hook of this.cfg.hooks.beforeRetry || []) {
+            await hook(res);
         }
         const { count, timeoutMultiplier, timeoutMax } = res.req.retry;
         if (retryStatus.retryAttempt >= count) {
@@ -316,6 +290,22 @@ export class Fetcher {
         }
         if (retryStatus.retryStopped)
             return;
+        // Here we know that more retries will be attempted
+        // We don't log "last error", because it will be thrown and logged by consumer,
+        // but we should log all previous errors, otherwise they are lost.
+        // Here is the right place where we know it's not the "last error"
+        if (res.err) {
+            const { retryAttempt } = retryStatus;
+            this.cfg.logger.error([
+                ' <<',
+                ((_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status) || 0,
+                res.signature,
+                `try#${retryAttempt + 1}/${count + 1}`,
+                _since(res.req.started),
+            ]
+                .filter(Boolean)
+                .join(' '), res.err.cause || res.err);
+        }
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
         const noise = Math.random() * 500;
@@ -419,7 +409,7 @@ export class Fetcher {
     normalizeOptions(url, opt) {
         var _a, _b;
         const { timeoutSeconds, throwHttpErrors, retryPost, retry4xx, retry5xx, retry, mode, jsonReviver, } = this.cfg;
-        const req = Object.assign(Object.assign({ mode,
+        const req = Object.assign(Object.assign({ started: Date.now(), mode,
             url,
             timeoutSeconds,
             throwHttpErrors,

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

@@ -102,7 +102,6 @@ export function _mapValues(obj, mapper, mutate = false) {
  * Does not support `mutate` flag.
  */
 export function _mapKeys(obj, mapper) {
-    // eslint-disable-next-line unicorn/prefer-object-from-entries
     return Object.entries(obj).reduce((map, [k, v]) => {
         map[mapper(k, v, obj)] = v;
         return map;

package/dist-esm/object/sortObjectDeep.js

@@ -5,7 +5,6 @@ import { _isObject } from '..';
 export function _sortObjectDeep(o) {
     // array
     if (Array.isArray(o)) {
-        // eslint-disable-next-line unicorn/no-array-callback-reference
         return o.map(_sortObjectDeep);
     }
     if (_isObject(o)) {

package/dist-esm/promise/pMap.js

@@ -6,7 +6,6 @@ Improvements:
 - Included Typescript typings (no need for @types/p-map)
 - Compatible with pProps (that had typings issues)
  */
-import { __asyncValues } from "tslib";
 import { END, ErrorMode, SKIP } from '..';
 /**
  * Returns a `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled,
@@ -35,7 +34,6 @@ import { END, ErrorMode, SKIP } from '..';
  * })();
  */
 export async function pMap(iterable, mapper, opt = {}) {
-    var _a, e_1, _b, _c;
     const ret = [];
     // const iterator = iterable[Symbol.iterator]()
     const items = [...iterable];
@@ -49,40 +47,23 @@ export async function pMap(iterable, mapper, opt = {}) {
     let currentIndex = 0;
     // Special cases that are able to preserve async stack traces
     if (concurrency === 1) {
-        try {
-            // Special case for concurrency == 1
-            for (var _d = true, items_1 = __asyncValues(items), items_1_1; items_1_1 = await items_1.next(), _a = items_1_1.done, !_a;) {
-                _c = items_1_1.value;
-                _d = false;
-                try {
-                    const item = _c;
-                    try {
-                        const r = await mapper(item, currentIndex++);
-                        if (r === END)
-                            break;
-                        if (r !== SKIP)
-                            ret.push(r);
-                    }
-                    catch (err) {
-                        if (errorMode === ErrorMode.THROW_IMMEDIATELY)
-                            throw err;
-                        if (errorMode === ErrorMode.THROW_AGGREGATED) {
-                            errors.push(err);
-                        }
-                        // otherwise, suppress completely
-                    }
-                }
-                finally {
-                    _d = true;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
+        // Special case for concurrency == 1
+        for (const item of items) {
             try {
-                if (!_d && !_a && (_b = items_1.return)) await _b.call(items_1);
+                const r = await mapper(item, currentIndex++);
+                if (r === END)
+                    break;
+                if (r !== SKIP)
+                    ret.push(r);
+            }
+            catch (err) {
+                if (errorMode === ErrorMode.THROW_IMMEDIATELY)
+                    throw err;
+                if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                    errors.push(err);
+                }
+                // otherwise, suppress completely
             }
-            finally { if (e_1) throw e_1.error; }
         }
         if (errors.length) {
             throw new AggregateError(errors, `pMap resulted in ${errors.length} error(s)`);

package/dist-esm/string/leven.js

@@ -56,7 +56,6 @@ export function _leven(first, second) {
         for (index = 0; index < firstLength; index++) {
             temporary2 = bCharacterCode === characterCodeCache[index] ? temporary : temporary + 1;
             temporary = array[index];
-            // eslint-disable-next-line no-multi-assign
             result = array[index] =
                 temporary > result
                     ? temporary2 > result

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

@@ -1,4 +1,3 @@
-/* eslint-disable unicorn/prefer-string-slice */
 /**
  * Converts the first character of string to upper case and the remaining to lower case.
  */

package/dist-esm/vendor/is.js

@@ -60,7 +60,6 @@ const primitiveTypeNames = [
 function isPrimitiveTypeName(name) {
     return primitiveTypeNames.includes(name);
 }
-// eslint-disable-next-line @typescript-eslint/ban-types
 function isOfType(type) {
     return (value) => typeof value === type;
 }
@@ -122,7 +121,6 @@ is.string = isOfType('string');
 const isNumberType = isOfType('number');
 is.number = (value) => isNumberType(value) && !is.nan(value);
 is.bigint = isOfType('bigint');
-// eslint-disable-next-line @typescript-eslint/ban-types
 is.function_ = isOfType('function');
 is.null_ = (value) => value === null;
 is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
@@ -151,7 +149,6 @@ is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
 is.generatorFunction = isObjectOfType('GeneratorFunction');
 is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
 is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction';
-// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
 is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
 is.regExp = isObjectOfType('RegExp');
 is.date = isObjectOfType('Date');
@@ -181,7 +178,7 @@ is.urlString = (value) => {
         return false;
     }
     try {
-        new URL(value); // eslint-disable-line no-new
+        new URL(value);
         return true;
     }
     catch (_a) {
@@ -341,7 +338,6 @@ export const assert = {
     string: (value) => assertType(is.string(value), 'string', value),
     number: (value) => assertType(is.number(value), 'number', value),
     bigint: (value) => assertType(is.bigint(value), 'bigint', value),
-    // eslint-disable-next-line @typescript-eslint/ban-types
     function_: (value) => assertType(is.function_(value), 'Function', value),
     null_: (value) => assertType(is.null_(value), 'null', value),
     class_: (value) => assertType(is.class_(value), AssertionTypeDescription.class_, value),
@@ -366,9 +362,7 @@ export const assert = {
     promise: (value) => assertType(is.promise(value), 'Promise', value),
     generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
     asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
-    // eslint-disable-next-line @typescript-eslint/ban-types
     asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value),
-    // eslint-disable-next-line @typescript-eslint/ban-types
     boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value),
     regExp: (value) => assertType(is.regExp(value), 'RegExp', value),
     date: (value) => assertType(is.date(value), 'Date', value),

package/package.json

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

package/src/array/array.util.ts

@@ -149,7 +149,7 @@ export function _sortBy<T>(
 ): T[] {
   const mod = descending ? -1 : 1
   return (mutate ? items : [...items]).sort((_a, _b) => {
-    const [a, b] = [_a, _b].map(mapper) // eslint-disable-line unicorn/no-array-callback-reference
+    const [a, b] = [_a, _b].map(mapper)
     if (typeof a === 'number' && typeof b === 'number') return (a - b) * mod
     return String(a).localeCompare(String(b)) * mod
   })
@@ -159,7 +159,7 @@ export function _sortBy<T>(
  * Like items.find(), but it tries to find from the END of the array.
  */
 export function _findLast<T>(items: T[], predicate: Predicate<T>): T | undefined {
-  return [...items].reverse().find(predicate) // eslint-disable-line unicorn/no-array-callback-reference
+  return [...items].reverse().find(predicate)
 }
 
 export function _takeWhile<T>(items: T[], predicate: Predicate<T>): T[] {

package/src/datetime/localDate.ts

@@ -17,8 +17,6 @@ const DATE_REGEX = /^(\d\d\d\d)-(\d\d)-(\d\d)$/
 export type LocalDateConfig = LocalDate | Date | IsoDateString
 export type LocalDateFormatter = (ld: LocalDate) => string
 
-/* eslint-disable no-dupe-class-members */
-
 /**
  * @experimental
  */

package/src/datetime/localTime.ts

@@ -40,8 +40,6 @@ const SECONDS_IN_DAY = 86400
 // const MILLISECONDS_IN_MINUTE = 60000
 const VALID_DAYS_OF_WEEK = new Set([1, 2, 3, 4, 5, 6, 7])
 
-/* eslint-disable no-dupe-class-members */
-
 /**
  * @experimental
  */

package/src/decorators/createPromiseDecorator.ts

@@ -52,7 +52,7 @@ export interface PromiseDecoratorResp<PARAMS> {
  *
  * @experimental
  */
-// eslint-disable-next-line @typescript-eslint/naming-convention
+
 export function _createPromiseDecorator<RES = any, PARAMS = any>(
   cfg: PromiseDecoratorCfg<RES, PARAMS>,
   decoratorParams: PARAMS = {} as any,

package/src/http/fetcher.model.ts

@@ -1,16 +1,24 @@
 import type { CommonLogger } from '../log/commonLogger'
 import type { Promisable } from '../typeFest'
-import type { Reviver } from '../types'
+import type { Reviver, UnixTimestampMillisNumber } from '../types'
 import type { HttpMethod, HttpStatusFamily } from './http.model'
 
-export interface FetcherNormalizedCfg extends Required<FetcherCfg>, FetcherRequest {
+export interface FetcherNormalizedCfg
+  extends Required<FetcherCfg>,
+    Omit<FetcherRequest, 'started'> {
   logger: CommonLogger
   searchParams: Record<string, any>
 }
 
-export type FetcherBeforeRequestHook = (req: FetcherRequest) => Promisable<void>
-export type FetcherAfterResponseHook = (res: FetcherResponse) => Promisable<void>
-export type FetcherBeforeRetryHook = (res: FetcherResponse) => Promisable<void>
+export type FetcherBeforeRequestHook = <BODY = unknown>(
+  req: FetcherRequest<BODY>,
+) => Promisable<void>
+export type FetcherAfterResponseHook = <BODY = unknown>(
+  res: FetcherResponse<BODY>,
+) => Promisable<void>
+export type FetcherBeforeRetryHook = <BODY = unknown>(
+  res: FetcherResponse<BODY>,
+) => Promisable<void>
 
 export interface FetcherCfg {
   /**
@@ -88,7 +96,8 @@ export interface FetcherRetryOptions {
   timeoutMultiplier: number
 }
 
-export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl'> {
+export interface FetcherRequest<BODY = unknown>
+  extends Omit<FetcherOptions<BODY>, 'method' | 'headers' | 'baseUrl'> {
   url: string
   init: RequestInitNormalized
   mode: FetcherMode
@@ -98,9 +107,10 @@ export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers
   retryPost: boolean
   retry4xx: boolean
   retry5xx: boolean
+  started: UnixTimestampMillisNumber
 }
 
-export interface FetcherOptions {
+export interface FetcherOptions<BODY = unknown> {
   method?: HttpMethod
 
   baseUrl?: string
@@ -159,6 +169,19 @@ export interface FetcherOptions {
   retry5xx?: boolean
 
   jsonReviver?: Reviver
+
+  /**
+   * Allows to walk over multiple pages of results.
+   * Paginate take a function.
+   * Function has access to FetcherRequest and FetcherResponse
+   * and has to make a decision to continue pagination or not.
+   * Return true to continue, false otherwise.
+   * If continue - it is expected to modify/mutate the FetcherRequest, as it will be used
+   * to request the next page.
+   *
+   * @experimental
+   */
+  paginate?: (req: FetcherRequest<BODY>, res: FetcherSuccessResponse<BODY>) => Promisable<boolean>
 }
 
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {
@@ -192,4 +215,4 @@ export type FetcherResponse<BODY = unknown> =
   | FetcherSuccessResponse<BODY>
   | FetcherErrorResponse<BODY>
 
-export type FetcherMode = 'json' | 'text' | 'void' | 'arrayBuffer' | 'blob'
+export type FetcherMode = 'json' | 'text' | 'void' | 'arrayBuffer' | 'blob' | 'readableStream'