request-got-adapter 0.1.0

package/dist/translate.js

@@ -0,0 +1,306 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepare = prepare;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_querystring_1 = __importDefault(require("node:querystring"));
+const form_data_1 = __importDefault(require("form-data"));
+const qs_1 = __importDefault(require("qs"));
+const cookies_1 = require("./cookies");
+const headers_1 = require("./headers");
+const oauth_1 = require("./oauth");
+const GAP_OPTIONS = [
+    'har',
+    'aws',
+    'httpSignature',
+    'proxy',
+    'tunnel',
+    'multipart',
+    'jsonReviver',
+    'jsonReplacer',
+    'pool',
+    'removeRefererHeader',
+    'preambleCRLF',
+    'postambleCRLF'
+];
+// request percent-encodes RFC 3986 reserved characters that encodeURIComponent leaves alone
+const rfc3986 = (value) => value.replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+// request-promise-core's defaultTransformations.HEAD: resolve headers instead of the empty body
+const defaultHeadTransform = (_body, response, resolveWithFullResponse) => resolveWithFullResponse ? response : response.headers;
+function resolveUri(options) {
+    let raw = options.uri ?? options.url;
+    if (raw !== null && typeof raw === 'object' && typeof raw.href === 'string')
+        raw = raw.href;
+    if (options.baseUrl !== undefined) {
+        if (typeof options.baseUrl !== 'string')
+            throw new Error('options.baseUrl must be a string');
+        if (typeof raw !== 'string')
+            throw new Error('options.uri must be a string when using options.baseUrl');
+        if (raw.startsWith('//') || /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(raw)) {
+            throw new Error('options.uri must be a path when using options.baseUrl');
+        }
+        const baseEndsWithSlash = options.baseUrl.endsWith('/');
+        const uriStartsWithSlash = raw.startsWith('/');
+        if (baseEndsWithSlash && uriStartsWithSlash)
+            return options.baseUrl + raw.slice(1);
+        if (baseEndsWithSlash || uriStartsWithSlash || raw === '')
+            return options.baseUrl + raw;
+        return `${options.baseUrl}/${raw}`;
+    }
+    if (raw === undefined || raw === null)
+        throw new Error('options.uri is a required argument');
+    if (typeof raw !== 'string')
+        throw new Error('options.uri must be a string');
+    if (!/^https?:/.test(raw))
+        throw new Error(`Invalid URI "${raw}"`);
+    return raw;
+}
+function applyQs(urlString, options) {
+    if (options.qs === undefined || Object.keys(options.qs).length === 0)
+        return urlString;
+    const queryIndex = urlString.indexOf('?');
+    const base = queryIndex === -1 ? urlString : urlString.slice(0, queryIndex);
+    const existing = queryIndex === -1 ? '' : urlString.slice(queryIndex + 1);
+    let serialized;
+    if (options.useQuerystring === true) {
+        const merged = { ...node_querystring_1.default.parse(existing), ...options.qs };
+        serialized = node_querystring_1.default.stringify(merged);
+    }
+    else {
+        const merged = { ...qs_1.default.parse(existing, options.qsParseOptions), ...options.qs };
+        serialized = qs_1.default.stringify(merged, options.qsStringifyOptions);
+    }
+    serialized = rfc3986(serialized);
+    return serialized === '' ? base : `${base}?${serialized}`;
+}
+function prepareBody(options, headers) {
+    let body = options.body;
+    let jsonMode = false;
+    if (options.json !== undefined && options.json !== false) {
+        jsonMode = true;
+        (0, headers_1.setHeaderIfAbsent)(headers, 'accept', 'application/json');
+        if (options.json !== true)
+            body = options.json;
+    }
+    if (options.form !== undefined) {
+        body =
+            typeof options.form === 'string'
+                ? rfc3986(options.form)
+                : rfc3986(qs_1.default.stringify(options.form, options.qsStringifyOptions));
+        (0, headers_1.setHeaderIfAbsent)(headers, 'content-type', 'application/x-www-form-urlencoded');
+        return { body, jsonMode };
+    }
+    if (options.formData !== undefined) {
+        const formData = new form_data_1.default();
+        for (const [field, entry] of Object.entries(options.formData)) {
+            appendFormDataEntry(formData, field, entry);
+        }
+        for (const [name, value] of Object.entries(formData.getHeaders())) {
+            (0, headers_1.setHeaderIfAbsent)(headers, name, value);
+        }
+        return { body: formData, jsonMode };
+    }
+    if (body !== undefined) {
+        if (jsonMode) {
+            const contentType = (0, headers_1.getHeader)(headers, 'content-type');
+            if (typeof contentType === 'string' && /^application\/x-www-form-urlencoded\b/.test(contentType)) {
+                body = rfc3986(String(body));
+            }
+            else {
+                body = JSON.stringify(body);
+                (0, headers_1.setHeaderIfAbsent)(headers, 'content-type', 'application/json');
+            }
+        }
+        else if (typeof body !== 'string' && !Buffer.isBuffer(body)) {
+            throw new TypeError('Argument error, options.body.');
+        }
+    }
+    return { body, jsonMode };
+}
+function appendFormDataEntry(formData, field, entry) {
+    if (Array.isArray(entry)) {
+        for (const item of entry)
+            appendFormDataEntry(formData, field, item);
+        return;
+    }
+    if (entry !== null && typeof entry === 'object' && 'value' in entry) {
+        const { value, options } = entry;
+        formData.append(field, value, options);
+        return;
+    }
+    formData.append(field, typeof entry === 'number' ? String(entry) : entry);
+}
+function applyImmediateAuth(options, headers) {
+    const auth = options.auth;
+    if (!auth)
+        return undefined;
+    if (auth.sendImmediately === false)
+        return auth;
+    if (auth.bearer !== undefined) {
+        const token = typeof auth.bearer === 'function' ? auth.bearer() : auth.bearer;
+        (0, headers_1.setHeaderIfAbsent)(headers, 'authorization', `Bearer ${token}`);
+    }
+    else {
+        const user = auth.user ?? auth.username ?? '';
+        const pass = auth.pass ?? auth.password ?? '';
+        (0, headers_1.setHeaderIfAbsent)(headers, 'authorization', `Basic ${Buffer.from(`${user}:${pass}`).toString('base64')}`);
+    }
+    return undefined;
+}
+// request pools agents keyed by their options; cache here so repeated calls reuse sockets
+const agentCache = new Map();
+function cachedAgents(agentOptions) {
+    const key = JSON.stringify(agentOptions);
+    let agents = agentCache.get(key);
+    if (!agents) {
+        agents = { http: new node_http_1.default.Agent(agentOptions), https: new node_https_1.default.Agent(agentOptions) };
+        agentCache.set(key, agents);
+    }
+    return agents;
+}
+function resolveAgents(options) {
+    if (options.agent)
+        return { http: options.agent, https: options.agent };
+    if (options.forever === true) {
+        return cachedAgents({ keepAlive: true, ...options.agentOptions });
+    }
+    if (options.agentOptions) {
+        return cachedAgents(options.agentOptions);
+    }
+    return undefined;
+}
+function buildHttpsOptions(options) {
+    const httpsOptions = {};
+    if (options.strictSSL === false || options.rejectUnauthorized === false)
+        httpsOptions.rejectUnauthorized = false;
+    if (options.ca !== undefined)
+        httpsOptions.certificateAuthority = options.ca;
+    if (options.cert !== undefined)
+        httpsOptions.certificate = options.cert;
+    if (options.key !== undefined)
+        httpsOptions.key = options.key;
+    if (options.pfx !== undefined)
+        httpsOptions.pfx = options.pfx;
+    if (options.passphrase !== undefined)
+        httpsOptions.passphrase = options.passphrase;
+    return Object.keys(httpsOptions).length > 0 ? httpsOptions : undefined;
+}
+function prepare(rpOptions) {
+    for (const gapOption of GAP_OPTIONS) {
+        if (rpOptions[gapOption] !== undefined) {
+            throw new Error(`request-got-adapter: option '${gapOption}' is not implemented (see README GAPS section)`);
+        }
+    }
+    if (typeof rpOptions.followRedirect === 'function') {
+        throw new Error("request-got-adapter: option 'followRedirect' as a function is not implemented (see README GAPS section)");
+    }
+    const method = (rpOptions.method ?? 'GET').toUpperCase();
+    const headers = { ...rpOptions.headers };
+    let url = applyQs(resolveUri(rpOptions), rpOptions);
+    const prepared = prepareBody(rpOptions, headers);
+    let body = prepared.body;
+    const jsonMode = prepared.jsonMode;
+    const deferredAuth = applyImmediateAuth(rpOptions, headers);
+    if (rpOptions.oauth) {
+        const contentType = (0, headers_1.getHeader)(headers, 'content-type');
+        const isUrlencodedForm = typeof contentType === 'string' &&
+            /^application\/x-www-form-urlencoded\b/.test(contentType) &&
+            typeof body === 'string';
+        const transport = rpOptions.oauth.transport_method ?? 'header';
+        if (transport === 'body' && (method !== 'POST' || !isUrlencodedForm)) {
+            throw new Error("oauth: transport_method of 'body' requires 'POST' and content-type 'application/x-www-form-urlencoded'");
+        }
+        const oauthParams = (0, oauth_1.buildOAuthParams)(rpOptions.oauth, method, url, isUrlencodedForm ? body : undefined, typeof body === 'string' || Buffer.isBuffer(body) ? body : undefined);
+        if (transport === 'header') {
+            (0, headers_1.setHeader)(headers, 'Authorization', (0, oauth_1.toOAuthHeader)(oauthParams));
+        }
+        else if (transport === 'query') {
+            url += (url.includes('?') ? '&' : '?') + (0, oauth_1.toOAuthQuery)(oauthParams);
+        }
+        else {
+            body = `${body}&${(0, oauth_1.toOAuthQuery)(oauthParams)}`;
+        }
+    }
+    const gotHeaders = { ...headers };
+    // got injects its own user-agent unless explicitly disabled; request sends none
+    if (!(0, headers_1.hasHeader)(gotHeaders, 'user-agent'))
+        gotHeaders['user-agent'] = undefined;
+    const decompress = rpOptions.gzip === true;
+    if (decompress)
+        (0, headers_1.setHeaderIfAbsent)(gotHeaders, 'accept-encoding', 'gzip, deflate');
+    const followRedirect = method === 'GET' || method === 'HEAD' ? rpOptions.followRedirect !== false : rpOptions.followAllRedirects === true;
+    const gotOptions = {
+        method,
+        headers: gotHeaders,
+        throwHttpErrors: false,
+        retry: { limit: 0 },
+        decompress,
+        followRedirect,
+        maxRedirects: rpOptions.maxRedirects ?? 10,
+        allowGetBody: true,
+        hooks: {
+            beforeRedirect: [
+                (updatedOptions, plainResponse) => {
+                    const status = plainResponse.statusCode;
+                    if (rpOptions.followOriginalHttpMethod === true) {
+                        updatedOptions.method = method;
+                        return;
+                    }
+                    if (status !== 307 && status !== 308 && updatedOptions.method !== 'HEAD') {
+                        updatedOptions.method = 'GET';
+                        updatedOptions.body = undefined;
+                        (0, headers_1.deleteHeader)(updatedOptions.headers, 'content-type');
+                        (0, headers_1.deleteHeader)(updatedOptions.headers, 'content-length');
+                    }
+                }
+            ]
+        }
+    };
+    if (body !== undefined)
+        gotOptions.body = body;
+    if (typeof rpOptions.timeout === 'number') {
+        gotOptions.timeout = {
+            lookup: rpOptions.timeout,
+            connect: rpOptions.timeout,
+            secureConnect: rpOptions.timeout,
+            response: rpOptions.timeout
+        };
+    }
+    const httpsOptions = buildHttpsOptions(rpOptions);
+    if (httpsOptions)
+        gotOptions.https = httpsOptions;
+    const agent = resolveAgents(rpOptions);
+    if (agent)
+        gotOptions.agent = agent;
+    const cookieJar = (0, cookies_1.resolveCookieJar)(rpOptions.jar);
+    if (cookieJar)
+        gotOptions.cookieJar = cookieJar;
+    if (rpOptions.localAddress !== undefined)
+        gotOptions.localAddress = rpOptions.localAddress;
+    if (rpOptions.family !== undefined)
+        gotOptions.dnsLookupIpVersion = rpOptions.family;
+    if (rpOptions.lookup !== undefined)
+        gotOptions.dnsLookup = rpOptions.lookup;
+    return {
+        url,
+        method,
+        gotOptions,
+        requestHeaders: headers,
+        simple: rpOptions.simple !== false,
+        resolveWithFullResponse: rpOptions.resolveWithFullResponse === true,
+        jsonMode,
+        encoding: rpOptions.encoding,
+        transform: typeof rpOptions.transform === 'function'
+            ? rpOptions.transform
+            : method === 'HEAD'
+                ? defaultHeadTransform
+                : undefined,
+        transform2xxOnly: rpOptions.transform2xxOnly === true,
+        time: rpOptions.time === true,
+        deferredAuth,
+        rpOptions
+    };
+}

package/errors.d.ts

@@ -0,0 +1 @@
+export * from './dist/errors'

package/errors.js

@@ -0,0 +1,3 @@
+// Mirrors require('request-promise-native/errors') for consumers using classic
+// (non-"exports") module resolution.
+module.exports = require('./dist/errors')

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "request-got-adapter",
+  "version": "0.1.0",
+  "description": "Drop-in replacement for request-promise-native, backed by got. Same API, same options, same errors — no deprecated request-family dependencies.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toriihq/request-got-adapter.git"
+  },
+  "keywords": [
+    "request",
+    "request-promise",
+    "request-promise-native",
+    "got",
+    "http",
+    "https",
+    "client",
+    "drop-in",
+    "adapter",
+    "migration"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./errors": {
+      "types": "./errors.d.ts",
+      "default": "./errors.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "errors.js",
+    "errors.d.ts"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "lint": "biome check src test type-fixtures",
+    "lint:fix": "biome check --write src test type-fixtures",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "form-data": "^4.0.6",
+    "got": "^14.6.6",
+    "qs": "^6.15.3",
+    "tough-cookie": "^6.0.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.0.0",
+    "@types/qs": "^6.14.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.6.0"
+  }
+}