@naturalcycles/js-lib 15.81.0 → 15.83.0

package/dist/http/fetcher.d.ts

@@ -4,7 +4,7 @@
 import type { ReadableStream as WebReadableStream } from 'node:stream/web';
 import { HttpRequestError } from '../error/error.util.js';
 import type { ErrorDataTuple } from '../types.js';
-import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherGraphQLOptions, FetcherNormalizedCfg, FetcherOnErrorHook, FetcherOptions, FetcherResponse, FetchFunction, RequestInitNormalized } from './fetcher.model.js';
+import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherGraphQLOptions, FetcherInitHook, FetcherNormalizedCfg, FetcherOnErrorHook, FetcherOptions, FetcherResponse, FetcherSuccessResponse, FetchFunction, RequestInitNormalized } from './fetcher.model.js';
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -16,7 +16,7 @@ export declare class Fetcher {
      *
      * Version is to be incremented every time a difference in behaviour (or a bugfix) is done.
      */
-    static readonly VERSION = 4;
+    static readonly VERSION = 5;
     /**
      * userAgent is statically exposed as Fetcher.userAgent.
      * It can be modified globally, and will be used (read) at the start of every request.
@@ -30,7 +30,20 @@ export declare class Fetcher {
     onAfterResponse(hook: FetcherAfterResponseHook): this;
     onBeforeRetry(hook: FetcherBeforeRetryHook): this;
     onError(hook: FetcherOnErrorHook): this;
+    /**
+     * Init hooks run lazily, once per Fetcher instance, before the first request.
+     * See FetcherInitHook docs.
+     */
+    onInit(hook: FetcherInitHook): this;
+    /**
+     * Clears the cached result of the init hooks, so they re-run before the next request.
+     * Useful when the state acquired during init (e.g an auth token) becomes stale.
+     * See also `cfg.hooks.shouldReinit`, which calls this automatically.
+     */
+    resetInit(): void;
     cfg: FetcherNormalizedCfg;
+    private initPromise?;
+    private initGeneration;
     static create(cfg?: FetcherCfg & FetcherOptions): Fetcher;
     get: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
     post: <T = unknown>(url: string, opt?: FetcherOptions) => Promise<T>;
@@ -56,10 +69,12 @@ export declare class Fetcher {
      * - Unwraps `response.errors` and throws, if it's defined (as GQL famously returns http 200 even for errors)
      *
      * Currently it only unwraps and uses the first error from the `errors` array, for simplicity.
-     *
-     * @experimental
      */
     queryGraphQL<T = unknown>(opt: FetcherGraphQLOptions): Promise<T>;
+    /**
+     * Returns response body as Uint8Array.
+     */
+    getBytes(url: string, opt?: FetcherOptions): Promise<Uint8Array>;
     /**
      * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>
      *
@@ -68,6 +83,16 @@ export declare class Fetcher {
      */
     getReadableStream(url: string, opt?: FetcherOptions): Promise<WebReadableStream<Uint8Array>>;
     fetch<T = unknown>(opt: FetcherOptions): Promise<T>;
+    /**
+     * Like `fetch`, but returns the whole FetcherSuccessResponse, not just the body.
+     * Allows to access response metadata, e.g `fetchResponse.headers` and `statusCode`,
+     * while still throwing on errors (unlike `doFetch`).
+     *
+     * Note: `throwHttpErrors: false` is ignored here, http errors are always thrown -
+     * otherwise the returned FetcherSuccessResponse type would lie.
+     * Use `doFetch` if you don't want throwing.
+     */
+    fetchWithMeta<T = unknown>(opt: FetcherOptions): Promise<FetcherSuccessResponse<T>>;
     /**
      * Execute fetch and expect/assert it to return an Error (which will be wrapped in
      * HttpRequestError as it normally would).
@@ -86,11 +111,19 @@ export declare class Fetcher {
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
+     * (Exception: errors thrown from init/beforeRequest hooks are re-thrown as-is.)
      * Use this method instead of `throwHttpErrors: false` or try-catching.
      *
-     * Note: responseType defaults to `void`, so, override it if you expect different.
+     * Note: responseType defaults to the Fetcher's cfg responseType (`json`, unless overridden).
      */
     doFetch<T = unknown>(opt: FetcherOptions): Promise<FetcherResponse<T>>;
+    /**
+     * Consults cfg.hooks.shouldReinit to detect "stale init" (e.g expired auth token).
+     * If detected - resets the init (so it re-runs) and returns true,
+     * telling the caller to retry the request. At most once per request.
+     */
+    private detectStaleInit;
+    private runInitHooks;
     private onOkResponse;
     /**
      * This method exists to be able to easily mock it.
@@ -99,6 +132,11 @@ export declare class Fetcher {
     static callNativeFetch(url: string, init: RequestInitNormalized, fetchFn?: FetchFunction): Promise<Response>;
     private onNotOkResponse;
     private processRetry;
+    /**
+     * Returns the delay before the next retry attempt.
+     * Returns null if the server-indicated delay exceeds `retry.maxRetryAfter`,
+     * meaning the retry should not be attempted at all.
+     */
     private getRetryTimeout;
     /**
      * Default is yes,

package/dist/http/fetcher.js

@@ -8,7 +8,7 @@ import { _assertErrorClassOrRethrow, _assertIsError } from '../error/assert.js';
 import { _anyToError, _anyToErrorObject, _errorDataAppend, _errorLikeToErrorObject, HttpRequestError, UnexpectedPassError, } from '../error/error.util.js';
 import { _clamp } from '../number/number.util.js';
 import { _filterFalsyValues, _filterNullishValues, _filterUndefinedValues, _mapKeys, _merge, _omit, _pick, } from '../object/object.util.js';
-import { pDelay } from '../promise/pDelay.js';
+import { pDelaySignal } from '../promise/pDelay.js';
 import { pTimeout } from '../promise/pTimeout.js';
 import { _toUrlOrNull } from '../string/index.js';
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util.js';
@@ -25,7 +25,7 @@ export class Fetcher {
      *
      * Version is to be incremented every time a difference in behaviour (or a bugfix) is done.
      */
-    static VERSION = 4;
+    static VERSION = 5;
     /**
      * userAgent is statically exposed as Fetcher.userAgent.
      * It can be modified globally, and will be used (read) at the start of every request.
@@ -47,9 +47,10 @@ export class Fetcher {
                     ...opt,
                 });
             };
-            if (method === 'HEAD')
-                return // responseType=text
-                ;
+            if (method === 'HEAD') {
+                continue; // responseType=text
+            }
+            ;
             this[`${m}Text`] = async (url, opt) => {
                 return await this.fetch({
                     url,
@@ -91,7 +92,27 @@ export class Fetcher {
         (this.cfg.hooks.onError ||= []).push(hook);
         return this;
     }
+    /**
+     * Init hooks run lazily, once per Fetcher instance, before the first request.
+     * See FetcherInitHook docs.
+     */
+    onInit(hook) {
+        ;
+        (this.cfg.hooks.init ||= []).push(hook);
+        return this;
+    }
+    /**
+     * Clears the cached result of the init hooks, so they re-run before the next request.
+     * Useful when the state acquired during init (e.g an auth token) becomes stale.
+     * See also `cfg.hooks.shouldReinit`, which calls this automatically.
+     */
+    resetInit() {
+        this.initPromise = undefined;
+        this.initGeneration++;
+    }
     cfg;
+    initPromise;
+    initGeneration = 0;
     static create(cfg = {}) {
         return new Fetcher(cfg);
     }
@@ -123,10 +144,9 @@ export class Fetcher {
      * - Unwraps `response.errors` and throws, if it's defined (as GQL famously returns http 200 even for errors)
      *
      * Currently it only unwraps and uses the first error from the `errors` array, for simplicity.
-     *
-     * @experimental
      */
     async queryGraphQL(opt) {
+        opt = { ...opt }; // avoid mutating the input options
         opt.method ||= this.cfg.init.method; // defaults to GET
         const payload = _filterFalsyValues({
             query: opt.query,
@@ -173,6 +193,17 @@ export class Fetcher {
         }
         return data;
     }
+    // responseType=bytes
+    /**
+     * Returns response body as Uint8Array.
+     */
+    async getBytes(url, opt) {
+        return await this.fetch({
+            url,
+            responseType: 'bytes',
+            ...opt,
+        });
+    }
     // responseType=readableStream
     /**
      * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>
@@ -189,11 +220,29 @@ export class Fetcher {
     }
     async fetch(opt) {
         const res = await this.doFetch(opt);
-        if (res.err) {
+        if (res.err && (res.req.throwHttpErrors || res.fetchResponse?.ok !== false)) {
+            // With throwHttpErrors=false only http errors (response received, but !ok) are returned instead of thrown.
+            // Other errors (network failure, timeout, body parsing) are still thrown.
             throw res.err;
         }
         return res.body;
     }
+    /**
+     * Like `fetch`, but returns the whole FetcherSuccessResponse, not just the body.
+     * Allows to access response metadata, e.g `fetchResponse.headers` and `statusCode`,
+     * while still throwing on errors (unlike `doFetch`).
+     *
+     * Note: `throwHttpErrors: false` is ignored here, http errors are always thrown -
+     * otherwise the returned FetcherSuccessResponse type would lie.
+     * Use `doFetch` if you don't want throwing.
+     */
+    async fetchWithMeta(opt) {
+        const res = await this.doFetch(opt);
+        if (res.err) {
+            throw res.err;
+        }
+        return res;
+    }
     /**
      * Execute fetch and expect/assert it to return an Error (which will be wrapped in
      * HttpRequestError as it normally would).
@@ -226,11 +275,24 @@ export class Fetcher {
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
+     * (Exception: errors thrown from init/beforeRequest hooks are re-thrown as-is.)
      * Use this method instead of `throwHttpErrors: false` or try-catching.
      *
-     * Note: responseType defaults to `void`, so, override it if you expect different.
+     * Note: responseType defaults to the Fetcher's cfg responseType (`json`, unless overridden).
      */
     async doFetch(opt) {
+        let initGeneration = 0;
+        if (this.cfg.hooks.init) {
+            try {
+                await (this.initPromise ??= this.runInitHooks());
+            }
+            catch (err) {
+                // Reset, so init hooks are re-attempted on the next request
+                this.resetInit();
+                throw err;
+            }
+            initGeneration = this.initGeneration;
+        }
         const req = this.normalizeOptions(opt);
         const { logger } = this.cfg;
         const { init: { method }, } = req;
@@ -253,6 +315,7 @@ export class Fetcher {
         };
         while (!res.retryStatus.retryStopped) {
             req.started = Date.now();
+            res.body = undefined;
             req.init.signal = abortSignalAnyOrUndefined([
                 abortSignalTimeoutOrUndefined(timeoutMillis),
                 opt.signal,
@@ -267,7 +330,7 @@ export class Fetcher {
                 }
             }
             try {
-                res.fetchResponse = await (this.cfg.overrideFetchFn || Fetcher.callNativeFetch)(req.fullUrl, req.init, this.cfg.fetchFn);
+                res.fetchResponse = await (req.overrideFetchFn || Fetcher.callNativeFetch)(req.fullUrl, req.init, req.fetchFn);
                 res.ok = res.fetchResponse.ok;
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.err = undefined;
@@ -283,11 +346,12 @@ export class Fetcher {
             }
             res.statusFamily = this.getStatusFamily(res);
             res.statusCode = res.fetchResponse?.status;
-            if (res.fetchResponse?.ok || !req.throwHttpErrors) {
+            if (res.fetchResponse?.ok) {
                 try {
                     // We are applying a separate Timeout (as long as original Timeout for now) to "download and parse the body"
                     await pTimeout(async () => await this.onOkResponse(res), {
-                        timeout: timeoutMillis || Number.POSITIVE_INFINITY,
+                        // 0 means "no timeout" for pTimeout
+                        timeout: timeoutMillis ?? 0,
                         name: 'Fetcher.downloadBody',
                     });
                 }
@@ -316,8 +380,36 @@ export class Fetcher {
         for (const hook of this.cfg.hooks.afterResponse || []) {
             await hook(res);
         }
+        if (res.err && (await this.detectStaleInit(opt, res, initGeneration))) {
+            // Stale init (e.g expired auth token) was detected and reset - retry the request once
+            return await this.doFetch({ ...opt, [reinitAttempted]: true });
+        }
         return res;
     }
+    /**
+     * Consults cfg.hooks.shouldReinit to detect "stale init" (e.g expired auth token).
+     * If detected - resets the init (so it re-runs) and returns true,
+     * telling the caller to retry the request. At most once per request.
+     */
+    async detectStaleInit(opt, res, initGeneration) {
+        const { shouldReinit, init } = this.cfg.hooks;
+        if (!shouldReinit || !init)
+            return false;
+        if (opt[reinitAttempted])
+            return false;
+        if (!(await shouldReinit(res)))
+            return false;
+        // Generation check prevents concurrent stale requests from resetting the already-fresh init
+        if (initGeneration === this.initGeneration) {
+            this.resetInit();
+        }
+        return true;
+    }
+    async runInitHooks() {
+        for (const hook of this.cfg.hooks.init || []) {
+            await hook(this.cfg);
+        }
+    }
     async onOkResponse(res) {
         const { req } = res;
         const { responseType } = res.req;
@@ -345,10 +437,20 @@ export class Fetcher {
             res.body = res.fetchResponse.body ? await res.fetchResponse.text() : '';
         }
         else if (responseType === 'arrayBuffer') {
-            res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {};
+            res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : new ArrayBuffer(0);
+        }
+        else if (responseType === 'bytes') {
+            // Not using fetchResponse.bytes(), as it's unavailable in older browsers (e.g Safari <18.4)
+            res.body = res.fetchResponse.body
+                ? new Uint8Array(await res.fetchResponse.arrayBuffer())
+                : new Uint8Array();
         }
         else if (responseType === 'blob') {
-            res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {};
+            res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : new Blob();
+        }
+        else if (responseType === 'void') {
+            // Cancel the body (without downloading it), to free the underlying connection for reuse
+            await res.fetchResponse.body?.cancel();
         }
         else if (responseType === 'readableStream') {
             res.body = res.fetchResponse.body;
@@ -358,8 +460,7 @@ export class Fetcher {
             }
         }
         res.retryStatus.retryStopped = true;
-        // res.err can happen on `failed to fetch` type of error, e.g JSON.parse, CORS, unexpected redirect
-        if ((!res.err || !req.throwHttpErrors) && req.logResponse) {
+        if (req.logResponse) {
             const { retryAttempt } = res.retryStatus;
             const { logger } = this.cfg;
             logger.log([
@@ -474,13 +575,28 @@ export class Fetcher {
         if (retryStatus.retryStopped)
             return;
         retryStatus.retryAttempt++;
-        retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
         const timeout = this.getRetryTimeout(res);
+        if (timeout === null) {
+            this.cfg.logger.warn(`${res.signature} server-indicated delay exceeds maxRetryAfter, will not retry`);
+            retryStatus.retryStopped = true;
+            return;
+        }
+        // Increase the timeout for the next possible retry
+        retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
         if (res.req.debug) {
             this.cfg.logger.log(` .. ${res.signature} waiting ${_ms(timeout)}`);
         }
-        await pDelay(timeout);
+        await pDelaySignal(timeout, res.req.signal);
+        if (res.req.signal?.aborted) {
+            // Aborted while waiting for the retry - stop, without issuing another request
+            retryStatus.retryStopped = true;
+        }
     }
+    /**
+     * Returns the delay before the next retry attempt.
+     * Returns null if the server-indicated delay exceeds `retry.maxRetryAfter`,
+     * meaning the retry should not be attempted at all.
+     */
     getRetryTimeout(res) {
         let timeout = 0;
         // Handling http 429 with specific retry headers
@@ -489,13 +605,21 @@ export class Fetcher {
             const retryAfterStr = res.fetchResponse.headers.get('retry-after') ??
                 res.fetchResponse.headers.get('x-ratelimit-reset');
             if (retryAfterStr) {
-                if (Number(retryAfterStr)) {
-                    timeout = Number(retryAfterStr) * 1000;
+                const retryAfterNumber = Number(retryAfterStr);
+                if (retryAfterNumber) {
+                    if (retryAfterNumber > 10 ** 9) {
+                        // Value is too large to be a "seconds from now" delay,
+                        // treat it as a UnixTimestamp instead (e.g GitHub sends `x-ratelimit-reset` like that)
+                        timeout = retryAfterNumber * 1000 - Date.now();
+                    }
+                    else {
+                        timeout = retryAfterNumber * 1000;
+                    }
                 }
                 else {
                     const date = new Date(retryAfterStr);
-                    if (!Number.isNaN(date)) {
-                        timeout = Number(date) - Date.now();
+                    if (!Number.isNaN(date.getTime())) {
+                        timeout = date.getTime() - Date.now();
                     }
                 }
                 this.cfg.logger.log(`retry-after: ${retryAfterStr}`);
@@ -504,11 +628,15 @@ export class Fetcher {
                 }
             }
         }
-        if (!timeout) {
-            const noise = Math.random() * 500;
-            timeout = res.retryStatus.retryTimeout + noise;
+        if (timeout) {
+            if (timeout > res.req.retry.maxRetryAfter) {
+                return null;
+            }
+            // Server-indicated delay is honored as-is (a negative value means "retry now")
+            return Math.max(0, timeout);
         }
-        return timeout;
+        const noise = Math.random() * 500;
+        return res.retryStatus.retryTimeout + noise;
     }
     /**
      * Default is yes,
@@ -635,6 +763,7 @@ export class Fetcher {
             ..._pick(this.cfg, [
                 'timeoutSeconds',
                 'retryPost',
+                'retry3xx',
                 'retry4xx',
                 'retry5xx',
                 'responseType',
@@ -646,6 +775,8 @@ export class Fetcher {
                 'debug',
                 'throwHttpErrors',
                 'errorData',
+                'fetchFn',
+                'overrideFetchFn',
             ]),
             started: Date.now(),
             ..._omit(opt, ['method', 'headers', 'credentials']),
@@ -691,13 +822,14 @@ export class Fetcher {
         }
         // setup request body
         // Unless it's a well-defined input type (json, text) - content-type is set automatically by the native fetch
+        // Explicitly passed `content-type` header always wins
         if (opt.json !== undefined) {
             req.init.body = JSON.stringify(opt.json);
-            req.init.headers['content-type'] = 'application/json';
+            req.init.headers['content-type'] ||= 'application/json';
         }
         else if (opt.text !== undefined) {
             req.init.body = opt.text;
-            req.init.headers['content-type'] = 'text/plain';
+            req.init.headers['content-type'] ||= 'text/plain';
         }
         else if (opt.form) {
             if (opt.form instanceof URLSearchParams || opt.form instanceof FormData) {
@@ -705,7 +837,7 @@ export class Fetcher {
             }
             else {
                 req.init.body = new URLSearchParams(opt.form);
-                req.init.headers['content-type'] = 'application/x-www-form-urlencoded';
+                req.init.headers['content-type'] ||= 'application/x-www-form-urlencoded';
             }
         }
         else if (opt.body !== undefined) {
@@ -719,12 +851,16 @@ export class Fetcher {
 export function getFetcher(cfg = {}) {
     return Fetcher.create(cfg);
 }
+// Marks FetcherOptions of a request that was already retried due to a reinit,
+// to guarantee at most one reinit per request
+const reinitAttempted = Symbol('reinitAttempted');
 const acceptByResponseType = {
     text: 'text/plain',
     json: 'application/json',
     void: '*/*',
     readableStream: 'application/octet-stream',
     arrayBuffer: 'application/octet-stream',
+    bytes: 'application/octet-stream',
     blob: 'application/octet-stream',
 };
 const defaultRetryOptions = {
@@ -732,4 +868,5 @@ const defaultRetryOptions = {
     timeout: 1000,
     timeoutMax: 30_000,
     timeoutMultiplier: 2,
+    maxRetryAfter: 600_000, // 10 minutes
 };

package/dist/http/fetcher.model.d.ts

@@ -18,6 +18,27 @@ export type FetcherBeforeRetryHook = <BODY = unknown>(res: FetcherResponse<BODY>
  * Cannot cancel/prevent the error - AfterResponseHook can be used for that instead.
  */
 export type FetcherOnErrorHook = (err: Error) => Promisable<void>;
+/**
+ * Init hooks run lazily, once per Fetcher instance, before the first request.
+ * All requests wait for the init hooks to complete, their result is cached,
+ * so they run at most once.
+ * If a hook throws - the error is re-thrown to the caller of the request,
+ * and init hooks are re-attempted on the next request.
+ *
+ * Receives the Fetcher's normalized cfg, which is allowed (and expected)
+ * to be mutated. Allows to do async initialization, e.g fetch an auth token
+ * and set `cfg.init.headers` based on it.
+ */
+export type FetcherInitHook = (cfg: FetcherNormalizedCfg) => Promisable<void>;
+/**
+ * Decides, based on the error response, if the Fetcher init state is "stale",
+ * e.g the auth token acquired in the init hook has expired.
+ * Returning true triggers `resetInit()`, so the init hooks re-run,
+ * and the request is then retried (at most once per request).
+ *
+ * Only consulted when init hooks are defined and the request resulted in an error.
+ */
+export type FetcherShouldReinitFn = (res: FetcherErrorResponse) => Promisable<boolean>;
 /**
  * FetcherCfg: configuration of the Fetcher instance. One per instance.
  * FetcherOptions: options for a single request. One per request.
@@ -39,6 +60,18 @@ export interface FetcherCfg {
      * If you throw an error from the hook - it will be re-thrown as-is.
      */
     hooks?: {
+        /**
+         * Runs lazily, once per Fetcher instance, before the first request.
+         * See FetcherInitHook docs.
+         */
+        init?: FetcherInitHook[];
+        /**
+         * Allows to detect "stale init" (e.g the auth token acquired in the init hook
+         * has expired) based on the error response, and trigger reinit+retry.
+         * Unlike other hooks, it's a single decision predicate, not an array.
+         * See FetcherShouldReinitFn docs.
+         */
+        shouldReinit?: FetcherShouldReinitFn;
         /**
          * Allows to mutate req.
          */
@@ -113,6 +146,16 @@ export interface FetcherRetryOptions {
     timeout: NumberOfMilliseconds;
     timeoutMax: NumberOfMilliseconds;
     timeoutMultiplier: number;
+    /**
+     * Upper limit for the server-indicated delay (`retry-after` and similar headers).
+     * Server-indicated delays within the limit are honored as-is (not affected by `timeoutMax`,
+     * which only limits the exponential backoff).
+     * If the server indicates a delay larger than this - the retry is NOT attempted,
+     * and the error is returned/thrown right away.
+     *
+     * Defaults to 10 minutes.
+     */
+    maxRetryAfter: NumberOfMilliseconds;
 }
 export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl' | 'url'> {
     /**
@@ -265,7 +308,9 @@ export interface FetcherOptions {
     overrideFetchFn?: FetchFunction;
     /**
      * Default to true.
-     * Set to false to not throw on `!Response.ok`, but simply return `Response.body` as-is (json parsed, etc).
+     * Set to false to not throw on http errors (`!Response.ok`), but simply return the response body as-is (json parsed, etc).
+     * Retries still apply as usual.
+     * Non-http errors (network failure, timeout, body parse error) are still thrown.
      */
     throwHttpErrors?: boolean;
     /**
@@ -318,7 +363,7 @@ export interface FetcherErrorResponse<BODY = unknown> {
     signature: string;
 }
 export type FetcherResponse<BODY = unknown> = FetcherSuccessResponse<BODY> | FetcherErrorResponse<BODY>;
-export type FetcherResponseType = 'json' | 'text' | 'void' | 'arrayBuffer' | 'blob' | 'readableStream';
+export type FetcherResponseType = 'json' | 'text' | 'void' | 'arrayBuffer' | 'bytes' | 'blob' | 'readableStream';
 /**
  * Signature for the `fetch` function.
  * Used to be able to override and provide a different implementation,

package/dist/promise/pDelay.d.ts

@@ -7,6 +7,11 @@ import type { DeferredPromise } from './pDefer.js';
  * If value is instanceof Error - rejects the Promise instead of resolving.
  */
 export declare function pDelay<T>(ms?: NumberOfMilliseconds, value?: T): Promise<T>;
+/**
+ * Like pDelay, but also resolves early (without an error) as soon as
+ * the passed AbortSignal aborts.
+ */
+export declare function pDelaySignal(ms: NumberOfMilliseconds, signal?: AbortSignal): Promise<void>;
 /**
  * Promisified version of setTimeout.
  *

package/dist/promise/pDelay.js

@@ -8,6 +8,23 @@ import { pDefer } from './pDefer.js';
 export async function pDelay(ms = 0, value) {
     return await new Promise((resolve, reject) => setTimeout(value instanceof Error ? reject : resolve, ms, value));
 }
+/**
+ * Like pDelay, but also resolves early (without an error) as soon as
+ * the passed AbortSignal aborts.
+ */
+export async function pDelaySignal(ms, signal) {
+    if (signal?.aborted)
+        return;
+    await new Promise(resolve => {
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', done);
+            resolve();
+        }
+        signal?.addEventListener('abort', done);
+    });
+}
 /* oxlint-disable @typescript-eslint/promise-function-async */
 /**
  * Promisified version of setTimeout.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.81.0",
+  "version": "15.83.0",
   "dependencies": {
     "tslib": "^2"
   },
@@ -17,7 +17,7 @@
     "@types/crypto-js": "^4",
     "@types/node": "^26",
     "@types/semver": "^7",
-    "typescript": "rc",
+    "typescript": "^7",
     "crypto-js": "^4",
     "dayjs": "^1",
     "@naturalcycles/dev-lib": "0.0.0"

package/src/http/fetcher.model.ts

@@ -47,6 +47,27 @@ export type FetcherBeforeRetryHook = <BODY = unknown>(
  * Cannot cancel/prevent the error - AfterResponseHook can be used for that instead.
  */
 export type FetcherOnErrorHook = (err: Error) => Promisable<void>
+/**
+ * Init hooks run lazily, once per Fetcher instance, before the first request.
+ * All requests wait for the init hooks to complete, their result is cached,
+ * so they run at most once.
+ * If a hook throws - the error is re-thrown to the caller of the request,
+ * and init hooks are re-attempted on the next request.
+ *
+ * Receives the Fetcher's normalized cfg, which is allowed (and expected)
+ * to be mutated. Allows to do async initialization, e.g fetch an auth token
+ * and set `cfg.init.headers` based on it.
+ */
+export type FetcherInitHook = (cfg: FetcherNormalizedCfg) => Promisable<void>
+/**
+ * Decides, based on the error response, if the Fetcher init state is "stale",
+ * e.g the auth token acquired in the init hook has expired.
+ * Returning true triggers `resetInit()`, so the init hooks re-run,
+ * and the request is then retried (at most once per request).
+ *
+ * Only consulted when init hooks are defined and the request resulted in an error.
+ */
+export type FetcherShouldReinitFn = (res: FetcherErrorResponse) => Promisable<boolean>
 
 /**
  * FetcherCfg: configuration of the Fetcher instance. One per instance.
@@ -71,6 +92,18 @@ export interface FetcherCfg {
    * If you throw an error from the hook - it will be re-thrown as-is.
    */
   hooks?: {
+    /**
+     * Runs lazily, once per Fetcher instance, before the first request.
+     * See FetcherInitHook docs.
+     */
+    init?: FetcherInitHook[]
+    /**
+     * Allows to detect "stale init" (e.g the auth token acquired in the init hook
+     * has expired) based on the error response, and trigger reinit+retry.
+     * Unlike other hooks, it's a single decision predicate, not an array.
+     * See FetcherShouldReinitFn docs.
+     */
+    shouldReinit?: FetcherShouldReinitFn
     /**
      * Allows to mutate req.
      */
@@ -155,6 +188,16 @@ export interface FetcherRetryOptions {
   timeout: NumberOfMilliseconds
   timeoutMax: NumberOfMilliseconds
   timeoutMultiplier: number
+  /**
+   * Upper limit for the server-indicated delay (`retry-after` and similar headers).
+   * Server-indicated delays within the limit are honored as-is (not affected by `timeoutMax`,
+   * which only limits the exponential backoff).
+   * If the server indicates a delay larger than this - the retry is NOT attempted,
+   * and the error is returned/thrown right away.
+   *
+   * Defaults to 10 minutes.
+   */
+  maxRetryAfter: NumberOfMilliseconds
 }
 
 export interface FetcherRequest extends Omit<
@@ -336,7 +379,9 @@ export interface FetcherOptions {
 
   /**
    * Default to true.
-   * Set to false to not throw on `!Response.ok`, but simply return `Response.body` as-is (json parsed, etc).
+   * Set to false to not throw on http errors (`!Response.ok`), but simply return the response body as-is (json parsed, etc).
+   * Retries still apply as usual.
+   * Non-http errors (network failure, timeout, body parse error) are still thrown.
    */
   throwHttpErrors?: boolean
 
@@ -404,6 +449,7 @@ export type FetcherResponseType =
   | 'text'
   | 'void'
   | 'arrayBuffer'
+  | 'bytes'
   | 'blob'
   | 'readableStream'
 

package/src/http/fetcher.ts

@@ -26,7 +26,7 @@ import {
   _omit,
   _pick,
 } from '../object/object.util.js'
-import { pDelay } from '../promise/pDelay.js'
+import { pDelaySignal } from '../promise/pDelay.js'
 import { pTimeout } from '../promise/pTimeout.js'
 import { _toUrlOrNull } from '../string/index.js'
 import { _jsonParse, _jsonParseIfPossible } from '../string/json.util.js'
@@ -42,7 +42,9 @@ import type {
   FetcherBeforeRequestHook,
   FetcherBeforeRetryHook,
   FetcherCfg,
+  FetcherErrorResponse,
   FetcherGraphQLOptions,
+  FetcherInitHook,
   FetcherNormalizedCfg,
   FetcherOnErrorHook,
   FetcherOptions,
@@ -50,6 +52,7 @@ import type {
   FetcherResponse,
   FetcherResponseType,
   FetcherRetryOptions,
+  FetcherSuccessResponse,
   FetchFunction,
   GraphQLResponse,
   RequestInitNormalized,
@@ -68,7 +71,7 @@ export class Fetcher {
    *
    * Version is to be incremented every time a difference in behaviour (or a bugfix) is done.
    */
-  static readonly VERSION = 4
+  static readonly VERSION = 5
   /**
    * userAgent is statically exposed as Fetcher.userAgent.
    * It can be modified globally, and will be used (read) at the start of every request.
@@ -96,7 +99,9 @@ export class Fetcher {
         })
       }
 
-      if (method === 'HEAD') return // responseType=text
+      if (method === 'HEAD') {
+        continue // responseType=text
+      }
       ;(this as any)[`${m}Text`] = async (url: string, opt?: FetcherOptions): Promise<string> => {
         return await this.fetch<string>({
           url,
@@ -141,8 +146,30 @@ export class Fetcher {
     return this
   }
 
+  /**
+   * Init hooks run lazily, once per Fetcher instance, before the first request.
+   * See FetcherInitHook docs.
+   */
+  onInit(hook: FetcherInitHook): this {
+    ;(this.cfg.hooks.init ||= []).push(hook)
+    return this
+  }
+
+  /**
+   * Clears the cached result of the init hooks, so they re-run before the next request.
+   * Useful when the state acquired during init (e.g an auth token) becomes stale.
+   * See also `cfg.hooks.shouldReinit`, which calls this automatically.
+   */
+  resetInit(): void {
+    this.initPromise = undefined
+    this.initGeneration++
+  }
+
   cfg: FetcherNormalizedCfg
 
+  private initPromise?: Promise<void>
+  private initGeneration = 0
+
   static create(cfg: FetcherCfg & FetcherOptions = {}): Fetcher {
     return new Fetcher(cfg)
   }
@@ -178,10 +205,9 @@ export class Fetcher {
    * - Unwraps `response.errors` and throws, if it's defined (as GQL famously returns http 200 even for errors)
    *
    * Currently it only unwraps and uses the first error from the `errors` array, for simplicity.
-   *
-   * @experimental
    */
   async queryGraphQL<T = unknown>(opt: FetcherGraphQLOptions): Promise<T> {
+    opt = { ...opt } // avoid mutating the input options
     opt.method ||= this.cfg.init.method // defaults to GET
 
     const payload: AnyObject = _filterFalsyValues({
@@ -236,6 +262,18 @@ export class Fetcher {
     return data
   }
 
+  // responseType=bytes
+  /**
+   * Returns response body as Uint8Array.
+   */
+  async getBytes(url: string, opt?: FetcherOptions): Promise<Uint8Array> {
+    return await this.fetch({
+      url,
+      responseType: 'bytes',
+      ...opt,
+    })
+  }
+
   // responseType=readableStream
   /**
    * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>
@@ -255,11 +293,30 @@ export class Fetcher {
   }
 
   async fetch<T = unknown>(opt: FetcherOptions): Promise<T> {
+    const res = await this.doFetch<T>(opt)
+    if (res.err && (res.req.throwHttpErrors || res.fetchResponse?.ok !== false)) {
+      // With throwHttpErrors=false only http errors (response received, but !ok) are returned instead of thrown.
+      // Other errors (network failure, timeout, body parsing) are still thrown.
+      throw res.err
+    }
+    return res.body as T
+  }
+
+  /**
+   * Like `fetch`, but returns the whole FetcherSuccessResponse, not just the body.
+   * Allows to access response metadata, e.g `fetchResponse.headers` and `statusCode`,
+   * while still throwing on errors (unlike `doFetch`).
+   *
+   * Note: `throwHttpErrors: false` is ignored here, http errors are always thrown -
+   * otherwise the returned FetcherSuccessResponse type would lie.
+   * Use `doFetch` if you don't want throwing.
+   */
+  async fetchWithMeta<T = unknown>(opt: FetcherOptions): Promise<FetcherSuccessResponse<T>> {
     const res = await this.doFetch<T>(opt)
     if (res.err) {
       throw res.err
     }
-    return res.body
+    return res
   }
 
   /**
@@ -298,11 +355,24 @@ export class Fetcher {
   /**
    * Returns FetcherResponse.
    * Never throws, returns `err` property in the response instead.
+   * (Exception: errors thrown from init/beforeRequest hooks are re-thrown as-is.)
    * Use this method instead of `throwHttpErrors: false` or try-catching.
    *
-   * Note: responseType defaults to `void`, so, override it if you expect different.
+   * Note: responseType defaults to the Fetcher's cfg responseType (`json`, unless overridden).
    */
   async doFetch<T = unknown>(opt: FetcherOptions): Promise<FetcherResponse<T>> {
+    let initGeneration = 0
+    if (this.cfg.hooks.init) {
+      try {
+        await (this.initPromise ??= this.runInitHooks())
+      } catch (err) {
+        // Reset, so init hooks are re-attempted on the next request
+        this.resetInit()
+        throw err
+      }
+      initGeneration = this.initGeneration
+    }
+
     const req = this.normalizeOptions(opt)
     const { logger } = this.cfg
     const {
@@ -331,6 +401,7 @@ export class Fetcher {
 
     while (!res.retryStatus.retryStopped) {
       req.started = Date.now() as UnixTimestampMillis
+      res.body = undefined
 
       req.init.signal = abortSignalAnyOrUndefined([
         abortSignalTimeoutOrUndefined(timeoutMillis),
@@ -350,10 +421,10 @@ export class Fetcher {
       }
 
       try {
-        res.fetchResponse = await (this.cfg.overrideFetchFn || Fetcher.callNativeFetch)(
+        res.fetchResponse = await (req.overrideFetchFn || Fetcher.callNativeFetch)(
           req.fullUrl,
           req.init,
-          this.cfg.fetchFn,
+          req.fetchFn,
         )
         res.ok = res.fetchResponse.ok
         // important to set it to undefined, otherwise it can keep the previous value (from previous try)
@@ -370,14 +441,15 @@ export class Fetcher {
       res.statusFamily = this.getStatusFamily(res)
       res.statusCode = res.fetchResponse?.status
 
-      if (res.fetchResponse?.ok || !req.throwHttpErrors) {
+      if (res.fetchResponse?.ok) {
         try {
           // We are applying a separate Timeout (as long as original Timeout for now) to "download and parse the body"
           await pTimeout(
             async () =>
               await this.onOkResponse(res as FetcherResponse<T> & { fetchResponse: Response }),
             {
-              timeout: timeoutMillis || Number.POSITIVE_INFINITY,
+              // 0 means "no timeout" for pTimeout
+              timeout: timeoutMillis ?? 0,
               name: 'Fetcher.downloadBody',
             },
           )
@@ -411,9 +483,42 @@ export class Fetcher {
       await hook(res)
     }
 
+    if (res.err && (await this.detectStaleInit(opt, res, initGeneration))) {
+      // Stale init (e.g expired auth token) was detected and reset - retry the request once
+      return await this.doFetch<T>({ ...opt, [reinitAttempted]: true } as FetcherOptions)
+    }
+
     return res
   }
 
+  /**
+   * Consults cfg.hooks.shouldReinit to detect "stale init" (e.g expired auth token).
+   * If detected - resets the init (so it re-runs) and returns true,
+   * telling the caller to retry the request. At most once per request.
+   */
+  private async detectStaleInit(
+    opt: FetcherOptions,
+    res: FetcherErrorResponse,
+    initGeneration: number,
+  ): Promise<boolean> {
+    const { shouldReinit, init } = this.cfg.hooks
+    if (!shouldReinit || !init) return false
+    if ((opt as any)[reinitAttempted]) return false
+    if (!(await shouldReinit(res))) return false
+
+    // Generation check prevents concurrent stale requests from resetting the already-fresh init
+    if (initGeneration === this.initGeneration) {
+      this.resetInit()
+    }
+    return true
+  }
+
+  private async runInitHooks(): Promise<void> {
+    for (const hook of this.cfg.hooks.init || []) {
+      await hook(this.cfg)
+    }
+  }
+
   private async onOkResponse(
     res: FetcherResponse<any> & { fetchResponse: Response },
   ): Promise<void> {
@@ -441,9 +546,17 @@ export class Fetcher {
     } else if (responseType === 'text') {
       res.body = res.fetchResponse.body ? await res.fetchResponse.text() : ''
     } else if (responseType === 'arrayBuffer') {
-      res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : {}
+      res.body = res.fetchResponse.body ? await res.fetchResponse.arrayBuffer() : new ArrayBuffer(0)
+    } else if (responseType === 'bytes') {
+      // Not using fetchResponse.bytes(), as it's unavailable in older browsers (e.g Safari <18.4)
+      res.body = res.fetchResponse.body
+        ? new Uint8Array(await res.fetchResponse.arrayBuffer())
+        : new Uint8Array()
     } else if (responseType === 'blob') {
-      res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : {}
+      res.body = res.fetchResponse.body ? await res.fetchResponse.blob() : new Blob()
+    } else if (responseType === 'void') {
+      // Cancel the body (without downloading it), to free the underlying connection for reuse
+      await res.fetchResponse.body?.cancel()
     } else if (responseType === 'readableStream') {
       res.body = res.fetchResponse.body
 
@@ -455,8 +568,7 @@ export class Fetcher {
 
     res.retryStatus.retryStopped = true
 
-    // res.err can happen on `failed to fetch` type of error, e.g JSON.parse, CORS, unexpected redirect
-    if ((!res.err || !req.throwHttpErrors) && req.logResponse) {
+    if (req.logResponse) {
       const { retryAttempt } = res.retryStatus
       const { logger } = this.cfg
       logger.log(
@@ -596,16 +708,33 @@ export class Fetcher {
     if (retryStatus.retryStopped) return
 
     retryStatus.retryAttempt++
+    const timeout = this.getRetryTimeout(res)
+    if (timeout === null) {
+      this.cfg.logger.warn(
+        `${res.signature} server-indicated delay exceeds maxRetryAfter, will not retry`,
+      )
+      retryStatus.retryStopped = true
+      return
+    }
+    // Increase the timeout for the next possible retry
     retryStatus.retryTimeout = _clamp(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax)
 
-    const timeout = this.getRetryTimeout(res)
     if (res.req.debug) {
       this.cfg.logger.log(` .. ${res.signature} waiting ${_ms(timeout)}`)
     }
-    await pDelay(timeout)
+    await pDelaySignal(timeout, res.req.signal)
+    if (res.req.signal?.aborted) {
+      // Aborted while waiting for the retry - stop, without issuing another request
+      retryStatus.retryStopped = true
+    }
   }
 
-  private getRetryTimeout(res: FetcherResponse): NumberOfMilliseconds {
+  /**
+   * Returns the delay before the next retry attempt.
+   * Returns null if the server-indicated delay exceeds `retry.maxRetryAfter`,
+   * meaning the retry should not be attempted at all.
+   */
+  private getRetryTimeout(res: FetcherResponse): NumberOfMilliseconds | null {
     let timeout: NumberOfMilliseconds = 0
 
     // Handling http 429 with specific retry headers
@@ -615,12 +744,19 @@ export class Fetcher {
         res.fetchResponse.headers.get('retry-after') ??
         res.fetchResponse.headers.get('x-ratelimit-reset')
       if (retryAfterStr) {
-        if (Number(retryAfterStr)) {
-          timeout = Number(retryAfterStr) * 1000
+        const retryAfterNumber = Number(retryAfterStr)
+        if (retryAfterNumber) {
+          if (retryAfterNumber > 10 ** 9) {
+            // Value is too large to be a "seconds from now" delay,
+            // treat it as a UnixTimestamp instead (e.g GitHub sends `x-ratelimit-reset` like that)
+            timeout = retryAfterNumber * 1000 - Date.now()
+          } else {
+            timeout = retryAfterNumber * 1000
+          }
         } else {
           const date = new Date(retryAfterStr)
-          if (!Number.isNaN(date)) {
-            timeout = Number(date) - Date.now()
+          if (!Number.isNaN(date.getTime())) {
+            timeout = date.getTime() - Date.now()
           }
         }
 
@@ -631,12 +767,16 @@ export class Fetcher {
       }
     }
 
-    if (!timeout) {
-      const noise = Math.random() * 500
-      timeout = res.retryStatus.retryTimeout + noise
+    if (timeout) {
+      if (timeout > res.req.retry.maxRetryAfter) {
+        return null
+      }
+      // Server-indicated delay is honored as-is (a negative value means "retry now")
+      return Math.max(0, timeout)
     }
 
-    return timeout
+    const noise = Math.random() * 500
+    return res.retryStatus.retryTimeout + noise
   }
 
   /**
@@ -775,6 +915,7 @@ export class Fetcher {
       ..._pick(this.cfg, [
         'timeoutSeconds',
         'retryPost',
+        'retry3xx',
         'retry4xx',
         'retry5xx',
         'responseType',
@@ -786,6 +927,8 @@ export class Fetcher {
         'debug',
         'throwHttpErrors',
         'errorData',
+        'fetchFn',
+        'overrideFetchFn',
       ]),
       started: Date.now() as UnixTimestampMillis,
       ..._omit(opt, ['method', 'headers', 'credentials']),
@@ -839,18 +982,19 @@ export class Fetcher {
 
     // setup request body
     // Unless it's a well-defined input type (json, text) - content-type is set automatically by the native fetch
+    // Explicitly passed `content-type` header always wins
     if (opt.json !== undefined) {
       req.init.body = JSON.stringify(opt.json)
-      req.init.headers['content-type'] = 'application/json'
+      req.init.headers['content-type'] ||= 'application/json'
     } else if (opt.text !== undefined) {
       req.init.body = opt.text
-      req.init.headers['content-type'] = 'text/plain'
+      req.init.headers['content-type'] ||= 'text/plain'
     } else if (opt.form) {
       if (opt.form instanceof URLSearchParams || opt.form instanceof FormData) {
         req.init.body = opt.form
       } else {
         req.init.body = new URLSearchParams(opt.form)
-        req.init.headers['content-type'] = 'application/x-www-form-urlencoded'
+        req.init.headers['content-type'] ||= 'application/x-www-form-urlencoded'
       }
     } else if (opt.body !== undefined) {
       req.init.body = opt.body
@@ -867,12 +1011,17 @@ export function getFetcher(cfg: FetcherCfg & FetcherOptions = {}): Fetcher {
   return Fetcher.create(cfg)
 }
 
+// Marks FetcherOptions of a request that was already retried due to a reinit,
+// to guarantee at most one reinit per request
+const reinitAttempted = Symbol('reinitAttempted')
+
 const acceptByResponseType: Record<FetcherResponseType, string> = {
   text: 'text/plain',
   json: 'application/json',
   void: '*/*',
   readableStream: 'application/octet-stream',
   arrayBuffer: 'application/octet-stream',
+  bytes: 'application/octet-stream',
   blob: 'application/octet-stream',
 }
 
@@ -881,4 +1030,5 @@ const defaultRetryOptions: FetcherRetryOptions = {
   timeout: 1000,
   timeoutMax: 30_000,
   timeoutMultiplier: 2,
+  maxRetryAfter: 600_000, // 10 minutes
 }

package/src/promise/pDelay.ts

@@ -14,6 +14,26 @@ export async function pDelay<T>(ms: NumberOfMilliseconds = 0, value?: T): Promis
   )
 }
 
+/**
+ * Like pDelay, but also resolves early (without an error) as soon as
+ * the passed AbortSignal aborts.
+ */
+export async function pDelaySignal(ms: NumberOfMilliseconds, signal?: AbortSignal): Promise<void> {
+  if (signal?.aborted) return
+
+  await new Promise<void>(resolve => {
+    const timer = setTimeout(done, ms)
+
+    function done(): void {
+      clearTimeout(timer)
+      signal?.removeEventListener('abort', done)
+      resolve()
+    }
+
+    signal?.addEventListener('abort', done)
+  })
+}
+
 /* oxlint-disable @typescript-eslint/promise-function-async */
 
 /**