@pnpm/network.fetch 1000.2.6

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @pnpm/fetch
+
+> node-fetch with retries
+
+<!--@shields('npm')-->
+[![npm version](https://img.shields.io/npm/v/@pnpm/fetch.svg)](https://www.npmjs.com/package/@pnpm/fetch)
+<!--/@-->
+
+## Installation
+
+```sh
+pnpm add @pnpm/fetch
+```
+
+## License
+
+MIT

package/lib/fetch.d.ts

@@ -0,0 +1,21 @@
+import { type RetryTimeoutOptions } from '@zkochan/retry';
+import { type Request, type RequestInit as NodeRequestInit, Response } from 'node-fetch';
+export { isRedirect } from 'node-fetch';
+export { Response, type RetryTimeoutOptions };
+interface URLLike {
+    href: string;
+}
+export type RequestInfo = string | URLLike | Request;
+export interface RequestInit extends NodeRequestInit {
+    retry?: RetryTimeoutOptions;
+    timeout?: number;
+}
+export declare function fetch(url: RequestInfo, opts?: RequestInit): Promise<Response>;
+export declare class ResponseError extends Error {
+    res: Response;
+    code: number;
+    status: number;
+    statusCode: number;
+    url: string;
+    constructor(res: Response);
+}

package/lib/fetch.js

@@ -0,0 +1,85 @@
+import assert from 'node:assert';
+import util from 'node:util';
+import { requestRetryLogger } from '@pnpm/core-loggers';
+import { operation } from '@zkochan/retry';
+import nodeFetch, { Response } from 'node-fetch';
+export { isRedirect } from 'node-fetch';
+export { Response };
+const NO_RETRY_ERROR_CODES = new Set([
+    'SELF_SIGNED_CERT_IN_CHAIN',
+    'ERR_OSSL_PEM_NO_START_LINE',
+]);
+export async function fetch(url, opts = {}) {
+    const retryOpts = opts.retry ?? {};
+    const maxRetries = retryOpts.retries ?? 2;
+    const op = operation({
+        factor: retryOpts.factor ?? 10,
+        maxTimeout: retryOpts.maxTimeout ?? 60000,
+        minTimeout: retryOpts.minTimeout ?? 10000,
+        randomize: false,
+        retries: maxRetries,
+    });
+    try {
+        return await new Promise((resolve, reject) => {
+            op.attempt(async (attempt) => {
+                try {
+                    // this will be retried
+                    const res = await nodeFetch(url, opts); // eslint-disable-line
+                    // A retry on 409 sometimes helps when making requests to the Bit registry.
+                    if ((res.status >= 500 && res.status < 600) || [408, 409, 420, 429].includes(res.status)) {
+                        throw new ResponseError(res);
+                    }
+                    else {
+                        resolve(res);
+                    }
+                }
+                catch (error) {
+                    assert(util.types.isNativeError(error));
+                    if ('code' in error &&
+                        typeof error.code === 'string' &&
+                        NO_RETRY_ERROR_CODES.has(error.code)) {
+                        throw error;
+                    }
+                    const timeout = op.retry(error);
+                    if (timeout === false) {
+                        reject(op.mainError());
+                        return;
+                    }
+                    requestRetryLogger.debug({
+                        attempt,
+                        error,
+                        maxRetries,
+                        method: opts.method ?? 'GET',
+                        timeout,
+                        url: url.toString(),
+                    });
+                }
+            });
+        });
+    }
+    catch (err) {
+        if (err instanceof ResponseError) {
+            return err.res;
+        }
+        throw err;
+    }
+}
+export class ResponseError extends Error {
+    res;
+    code;
+    status;
+    statusCode;
+    url;
+    constructor(res) {
+        super(res.statusText);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ResponseError);
+        }
+        this.name = this.constructor.name;
+        this.res = res;
+        // backward compat
+        this.code = this.status = this.statusCode = res.status;
+        this.url = res.url;
+    }
+}
+//# sourceMappingURL=fetch.js.map

package/lib/fetchFromRegistry.d.ts

@@ -0,0 +1,14 @@
+import type { FetchFromRegistry } from '@pnpm/fetching.types';
+import { type AgentOptions } from '@pnpm/network.agent';
+import type { SslConfig } from '@pnpm/types';
+import { type RequestInfo, type RequestInit, type Response } from './fetch.js';
+export interface FetchWithAgentOptions extends RequestInit {
+    agentOptions: AgentOptions;
+}
+export declare function fetchWithAgent(url: RequestInfo, opts: FetchWithAgentOptions): Promise<Response>;
+export type { AgentOptions };
+export interface CreateFetchFromRegistryOptions extends AgentOptions {
+    userAgent?: string;
+    sslConfigs?: Record<string, SslConfig>;
+}
+export declare function createFetchFromRegistry(defaultOpts: CreateFetchFromRegistryOptions): FetchFromRegistry;

package/lib/fetchFromRegistry.js

@@ -0,0 +1,91 @@
+import { URL } from 'node:url';
+import { getAgent } from '@pnpm/network.agent';
+import { fetch, isRedirect } from './fetch.js';
+const USER_AGENT = 'pnpm'; // or maybe make it `${pkg.name}/${pkg.version} (+https://npm.im/${pkg.name})`
+const FULL_DOC = 'application/json';
+const ACCEPT_FULL_DOC = `${FULL_DOC}; q=1.0, */*`;
+const ABBREVIATED_DOC = 'application/vnd.npm.install-v1+json';
+const ACCEPT_ABBREVIATED_DOC = `${ABBREVIATED_DOC}; q=1.0, ${FULL_DOC}; q=0.8, */*`;
+const MAX_FOLLOWED_REDIRECTS = 20;
+export function fetchWithAgent(url, opts) {
+    const agent = getAgent(url.toString(), {
+        ...opts.agentOptions,
+        strictSsl: opts.agentOptions.strictSsl ?? true,
+    }); // eslint-disable-line
+    const headers = opts.headers ?? {};
+    // @ts-expect-error
+    headers['connection'] = agent ? 'keep-alive' : 'close';
+    return fetch(url, {
+        ...opts,
+        agent,
+    });
+}
+export function createFetchFromRegistry(defaultOpts) {
+    return async (url, opts) => {
+        const headers = {
+            'user-agent': USER_AGENT,
+            ...getHeaders({
+                auth: opts?.authHeaderValue,
+                fullMetadata: opts?.fullMetadata,
+                userAgent: defaultOpts.userAgent,
+            }),
+        };
+        let redirects = 0;
+        let urlObject = new URL(url);
+        const originalHost = urlObject.host;
+        /* eslint-disable no-await-in-loop */
+        while (true) {
+            const agentOptions = {
+                ...defaultOpts,
+                ...opts,
+                strictSsl: defaultOpts.strictSsl ?? true,
+            }; // eslint-disable-line
+            // We should pass a URL object to node-fetch till this is not resolved:
+            // https://github.com/bitinn/node-fetch/issues/245
+            const response = await fetchWithAgent(urlObject, {
+                agentOptions: {
+                    ...agentOptions,
+                    clientCertificates: defaultOpts.sslConfigs,
+                },
+                // if verifying integrity, node-fetch must not decompress
+                compress: opts?.compress ?? false,
+                method: opts?.method,
+                headers,
+                redirect: 'manual',
+                retry: opts?.retry,
+                timeout: opts?.timeout ?? 60000,
+            });
+            if (!isRedirect(response.status) || redirects >= MAX_FOLLOWED_REDIRECTS) {
+                return response;
+            }
+            redirects++;
+            // This is a workaround to remove authorization headers on redirect.
+            // Related pnpm issue: https://github.com/pnpm/pnpm/issues/1815
+            urlObject = resolveRedirectUrl(response, urlObject);
+            if (!headers['authorization'] || originalHost === urlObject.host)
+                continue;
+            delete headers.authorization;
+        }
+        /* eslint-enable no-await-in-loop */
+    };
+}
+function getHeaders(opts) {
+    const headers = {
+        accept: opts.fullMetadata === true ? ACCEPT_FULL_DOC : ACCEPT_ABBREVIATED_DOC,
+    };
+    if (opts.auth) {
+        headers['authorization'] = opts.auth;
+    }
+    if (opts.userAgent) {
+        headers['user-agent'] = opts.userAgent;
+    }
+    return headers;
+}
+function resolveRedirectUrl(response, currentUrl) {
+    const location = response.headers.get('location');
+    if (!location) {
+        throw new Error(`Redirect location header missing for ${currentUrl.toString()}`);
+    }
+    return new URL(location, currentUrl);
+}
+//# sourceMappingURL=fetchFromRegistry.js.map

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { fetch, type RetryTimeoutOptions } from './fetch.js';
+export { type AgentOptions, createFetchFromRegistry, type CreateFetchFromRegistryOptions, fetchWithAgent } from './fetchFromRegistry.js';
+export type { FetchFromRegistry } from '@pnpm/fetching.types';

package/lib/index.js

@@ -0,0 +1,3 @@
+export { fetch } from './fetch.js';
+export { createFetchFromRegistry, fetchWithAgent } from './fetchFromRegistry.js';
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@pnpm/network.fetch",
+  "version": "1000.2.6",
+  "description": "node-fetch with retries",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "fetch",
+    "npm"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/network/fetch",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/network/fetch#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@pnpm/network.agent": "^2.0.3",
+    "@zkochan/retry": "^0.2.0",
+    "node-fetch": "^3.3.2",
+    "@pnpm/core-loggers": "1001.0.4",
+    "@pnpm/fetching.types": "1000.2.0",
+    "@pnpm/types": "1000.9.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "https-proxy-server-express": "0.1.2",
+    "nock": "13.3.4",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/network.fetch": "1000.2.6"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}