request-got-adapter 0.1.1 → 0.1.3

package/README.md

@@ -112,6 +112,7 @@ One deliberate improvement over the reference: passing an object `body` without
 | `agent` / `agentOptions` / `forever` / `.forever()` | ✅ |
 | `jar` / `request.jar()` / `request.cookie()` (tough-cookie) | ✅ |
 | `transform` / `transform2xxOnly` | ✅ |
+| `response.caseless` (case-insensitive header helper) | ✅ |
 | `localAddress` / `family` / `lookup` | ✅ |
 | `.defaults()` (chainable) | ✅ |
 | Callback style `(err, response, body)` alongside promises | ✅ |

package/dist/core.js

@@ -46,6 +46,23 @@ function toRequestError(err, prepared) {
     }
     return new errors_1.RequestError(cause, prepared.rpOptions, undefined);
 }
+const errorListenerAttached = Symbol.for('request-got-adapter.errorListenerAttached');
+const swallowLateErrors = () => { };
+// request kept 'error' listeners on the request and its socket for their whole
+// lifetime; without this, late socket errors emitted after got settles (seen with
+// keep-alive reuse and mocked sockets) become unhandled 'error' events.
+function attachDefensiveErrorListeners(pending) {
+    const promiseWithEvents = pending;
+    promiseWithEvents.on?.('request', (request) => {
+        request.on('error', swallowLateErrors);
+        request.on('socket', (socket) => {
+            if (!socket[errorListenerAttached]) {
+                socket[errorListenerAttached] = true;
+                socket.on('error', swallowLateErrors);
+            }
+        });
+    });
+}
 async function gotCall(prepared, extraHeaders) {
     const gotModule = await (0, got_loader_1.loadGot)();
     const got = gotModule.default;
@@ -56,7 +73,9 @@ async function gotCall(prepared, extraHeaders) {
         }
         : prepared.gotOptions;
     try {
-        return await got(prepared.url, options);
+        const pending = got(prepared.url, options);
+        attachDefensiveErrorListeners(pending);
+        return await pending;
     }
     catch (err) {
         throw toRequestError(err, prepared);

package/dist/errors.d.ts

@@ -1,24 +1,24 @@
 export declare class StatusCodeError extends Error {
     name: "StatusCodeError";
     statusCode: number;
-    error: unknown;
-    options: unknown;
-    response: unknown;
+    error: any;
+    options: any;
+    response: any;
     constructor(statusCode: number, body: unknown, options?: unknown, response?: unknown);
 }
 export declare class RequestError extends Error {
     name: "RequestError";
-    cause: unknown;
-    error: unknown;
-    options: unknown;
-    response: unknown;
+    cause: any;
+    error: any;
+    options: any;
+    response: any;
     constructor(cause: unknown, options?: unknown, response?: unknown);
 }
 export declare class TransformError extends Error {
     name: "TransformError";
-    cause: unknown;
-    error: unknown;
-    options: unknown;
-    response: unknown;
+    cause: any;
+    error: any;
+    options: any;
+    response: any;
     constructor(cause: unknown, options?: unknown, response?: unknown);
 }

package/dist/errors.js

@@ -1,7 +1,18 @@
 "use strict";
-// Error classes matching request-promise-core's errors 1:1 (names, fields, message formats).
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformError = exports.RequestError = exports.StatusCodeError = void 0;
+// Error classes matching request-promise-core's errors 1:1 (names, fields, message formats).
+// request-promise-core assigns `this.message` in plain constructors, making it an
+// ENUMERABLE own property — consumers rely on `{ ...err }` spreads and JSON.stringify
+// keeping the message, so mirror that explicitly (ES class super() makes it non-enumerable).
+function exposeMessage(error, message) {
+    Object.defineProperty(error, 'message', {
+        value: message,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    });
+}
 class StatusCodeError extends Error {
     name = 'StatusCodeError';
     statusCode;
@@ -9,7 +20,9 @@ class StatusCodeError extends Error {
     options;
     response;
     constructor(statusCode, body, options, response) {
-        super(`${statusCode} - ${JSON.stringify(body)}`);
+        const message = `${statusCode} - ${JSON.stringify(body)}`;
+        super(message);
+        exposeMessage(this, message);
         this.statusCode = statusCode;
         this.error = body;
         this.options = options;
@@ -25,7 +38,9 @@ class RequestError extends Error {
     options;
     response;
     constructor(cause, options, response) {
-        super(String(cause));
+        const message = String(cause);
+        super(message);
+        exposeMessage(this, message);
         this.cause = cause;
         this.error = cause;
         this.options = options;
@@ -41,7 +56,9 @@ class TransformError extends Error {
     options;
     response;
     constructor(cause, options, response) {
-        super(String(cause));
+        const message = String(cause);
+        super(message);
+        exposeMessage(this, message);
         this.cause = cause;
         this.error = cause;
         this.options = options;

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { type RequestJar, jar as createJar, cookie as parseCookieString } from './cookies';
+import { jar as createJar, cookie as parseCookieString } from './cookies';
 import { RequestError as RequestErrorClass, StatusCodeError as StatusCodeErrorClass, TransformError as TransformErrorClass } from './errors';
 import type { FullResponse as FullResponseShape } from './response';
 import type { AuthOptions, OAuthOptions } from './rp-options';
 declare function requestGotAdapter(uriOrOptions: string | requestGotAdapter.Options, optionsOrCallback?: requestGotAdapter.RequestPromiseOptions | requestGotAdapter.RequestCallback, callback?: requestGotAdapter.RequestCallback): requestGotAdapter.RequestPromise;
 declare namespace requestGotAdapter {
-    type RequestCallback = (error: unknown, response: FullResponse, body: unknown) => void;
+    type RequestCallback = (error: any, response: any, body: any) => void;
     type FullResponse = FullResponseShape;
     interface RequestPromise<T = any> extends Promise<T> {
         promise(): Promise<T>;
@@ -29,7 +29,7 @@ declare namespace requestGotAdapter {
         time?: boolean;
         simple?: boolean;
         resolveWithFullResponse?: boolean;
-        followRedirect?: boolean;
+        followRedirect?: boolean | ((response: any) => boolean);
         followAllRedirects?: boolean;
         followOriginalHttpMethod?: boolean;
         maxRedirects?: number;
@@ -62,7 +62,11 @@ declare namespace requestGotAdapter {
         };
     }
     type Options = OptionsWithUri | OptionsWithUrl;
-    type CookieJar = RequestJar;
+    interface CookieJar {
+        setCookie: (cookieOrString: any, uri: string, options?: any) => any;
+        getCookieString: (uri: string) => string;
+        getCookies: (uri: string) => any[];
+    }
     interface RequestPromiseCall {
         (options: Options, callback?: RequestCallback): RequestPromise;
         (uri: string, options?: RequestPromiseOptions, callback?: RequestCallback): RequestPromise;
@@ -85,17 +89,17 @@ declare namespace requestGotAdapter {
         RequestError: typeof RequestErrorClass;
         TransformError: typeof TransformErrorClass;
     }
-    const get: RequestPromiseCall;
-    const head: RequestPromiseCall;
-    const options: RequestPromiseCall;
-    const post: RequestPromiseCall;
-    const put: RequestPromiseCall;
-    const patch: RequestPromiseCall;
-    const del: RequestPromiseCall;
-    const defaults: (options: RequestPromiseOptions) => RequestPromiseAPI;
-    const forever: (agentOptions?: Record<string, any>) => RequestPromiseAPI;
-    const jar: typeof createJar;
-    const cookie: typeof parseCookieString;
+    let get: RequestPromiseCall;
+    let head: RequestPromiseCall;
+    let options: RequestPromiseCall;
+    let post: RequestPromiseCall;
+    let put: RequestPromiseCall;
+    let patch: RequestPromiseCall;
+    let del: RequestPromiseCall;
+    let defaults: (options: RequestPromiseOptions) => RequestPromiseAPI;
+    let forever: (agentOptions?: Record<string, any>) => RequestPromiseAPI;
+    let jar: typeof createJar;
+    let cookie: typeof parseCookieString;
     const StatusCodeError: typeof StatusCodeErrorClass;
     const RequestError: typeof RequestErrorClass;
     const TransformError: typeof TransformErrorClass;

package/dist/index.js

@@ -35,6 +35,8 @@ function requestGotAdapter(uriOrOptions, optionsOrCallback, callback) {
 }
 // Mirrors @types/request-promise-native's export= namespace shape
 (function (requestGotAdapter) {
+    // `let` on purpose: @types/request-promise-native models these as mutable
+    // interface members, and tests commonly assign mocks (rp.post = jest.fn())
     requestGotAdapter.get = baseApi.get;
     requestGotAdapter.head = baseApi.head;
     requestGotAdapter.options = baseApi.options;

package/dist/response.d.ts

@@ -24,6 +24,13 @@ interface GotResponseLike {
         };
     };
 }
+export interface Caseless {
+    get: (name: string) => unknown;
+    has: (name: string) => string | false;
+    set: (name: string, value: unknown) => void;
+    del: (name: string) => void;
+    swap: (name: string) => void;
+}
 export interface FullResponse {
     statusCode: number;
     statusMessage?: string;
@@ -31,6 +38,7 @@ export interface FullResponse {
     rawHeaders?: string[];
     httpVersion?: string;
     body: unknown;
+    caseless: Caseless;
     request: {
         uri: ReturnType<typeof parseLegacyUrl>;
         method: string;

package/dist/response.js

@@ -2,6 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFullResponse = buildFullResponse;
 const node_url_1 = require("node:url");
+// request responses carry a `caseless` helper for case-insensitive header access
+function makeCaseless(headers) {
+    const findKey = (name) => {
+        const lower = name.toLowerCase();
+        return Object.keys(headers).find((key) => key.toLowerCase() === lower);
+    };
+    return {
+        get(name) {
+            const key = findKey(name);
+            return key === undefined ? undefined : headers[key];
+        },
+        has(name) {
+            return findKey(name) ?? false;
+        },
+        set(name, value) {
+            headers[findKey(name) ?? name] = value;
+        },
+        del(name) {
+            const key = findKey(name);
+            if (key !== undefined)
+                delete headers[key];
+        },
+        swap(name) {
+            const key = findKey(name);
+            if (key === undefined || key === name)
+                return;
+            headers[name] = headers[key];
+            delete headers[key];
+        }
+    };
+}
 function buildFullResponse(gotResponse, prepared, body) {
     const finalMethod = gotResponse.request?.options?.method ?? prepared.method;
     const requestPart = {
@@ -16,6 +47,7 @@ function buildFullResponse(gotResponse, prepared, body) {
         rawHeaders: gotResponse.rawHeaders,
         httpVersion: gotResponse.httpVersion,
         body,
+        caseless: makeCaseless(gotResponse.headers),
         request: requestPart,
         toJSON() {
             return {

package/dist/translate.js

@@ -224,6 +224,14 @@ function prepare(rpOptions) {
             body = `${body}&${(0, oauth_1.toOAuthQuery)(oauthParams)}`;
         }
     }
+    // request computes content-length (as a number) for string/Buffer bodies and
+    // records it on the outgoing headers — visible via response.request.headers
+    if (body !== undefined && !(0, headers_1.hasHeader)(headers, 'content-length')) {
+        if (typeof body === 'string')
+            headers['content-length'] = Buffer.byteLength(body);
+        else if (Buffer.isBuffer(body))
+            headers['content-length'] = body.length;
+    }
     const gotHeaders = { ...headers };
     // got injects its own user-agent unless explicitly disabled; request sends none
     if (!(0, headers_1.hasHeader)(gotHeaders, 'user-agent'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "request-got-adapter",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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": {