@automattic/request-promise-native 2.1.1 → 2.2.0

package/deps/promise-core/package.json

@@ -35,11 +35,10 @@
     "request": "npm:@cypress/request@^3.0.7"
   },
   "devDependencies": {
-    "bluebird": "~3.4.1",
+    "bluebird": "~3.7.2",
     "body-parser": "^1.20.3",
     "chai": "^4.5.0",
     "mocha": "^11.1.0",
-    "node-version": "^3.0.0",
-    "stealthy-require": "~1.0.0"
+    "stealthy-require": "~1.1.1"
   }
 }

package/errors.js

@@ -1 +1 @@
-module.exports = require('request-promise-core/errors');
+module.exports = require('./deps/promise-core/errors.js');

package/lib/request.d.ts

@@ -0,0 +1,393 @@
+// See https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/request/index.d.ts
+
+import caseless from "caseless";
+import { Stream, Readable } from "node:stream";
+import http from "node:http";
+import https from "node:https";
+import FormData from "form-data";
+import net from "node:net";
+import ToughCookie from "tough-cookie";
+import { Url } from "node:url";
+
+declare namespace request {
+    interface RequestAPI<TRequest extends Request, TOptions extends CoreOptions, TUriUrlOptions> {
+        defaults(options: TOptions): RequestAPI<TRequest, TOptions, RequiredUriUrl>;
+        defaults(options: RequiredUriUrl & TOptions): DefaultUriUrlRequestApi<TRequest, TOptions, OptionalUriUrl>;
+
+        (uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        (uri: string, callback?: RequestCallback): TRequest;
+        (options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+        get(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        get(uri: string, callback?: RequestCallback): TRequest;
+        get(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+        post(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        post(uri: string, callback?: RequestCallback): TRequest;
+        post(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+        put(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        put(uri: string, callback?: RequestCallback): TRequest;
+        put(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+        head(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        head(uri: string, callback?: RequestCallback): TRequest;
+        head(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+        patch(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        patch(uri: string, callback?: RequestCallback): TRequest;
+        patch(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+        del(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        del(uri: string, callback?: RequestCallback): TRequest;
+        del(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+        delete(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        delete(uri: string, callback?: RequestCallback): TRequest;
+        delete(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+        initParams(uri: string, options?: TOptions, callback?: RequestCallback): RequiredUriUrl & TOptions;
+        initParams(
+            uriOrOpts: string | RequiredUriUrl & TOptions,
+            callback?: RequestCallback,
+        ): RequiredUriUrl & TOptions;
+
+        forever(agentOptions: any, optionsArg: any): TRequest;
+        jar(store?: any): CookieJar;
+        cookie(str: string): Cookie | undefined;
+
+        debug: boolean;
+    }
+
+    interface DefaultUriUrlRequestApi<TRequest extends Request, TOptions extends CoreOptions, TUriUrlOptions>
+        extends RequestAPI<TRequest, TOptions, TUriUrlOptions>
+    {
+        defaults(options: TOptions): DefaultUriUrlRequestApi<TRequest, TOptions, OptionalUriUrl>;
+        (callback?: RequestCallback): TRequest;
+
+        get(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        get(uri: string, callback?: RequestCallback): TRequest;
+        get(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+        get(callback?: RequestCallback): TRequest;
+
+        post(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        post(uri: string, callback?: RequestCallback): TRequest;
+        post(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+        post(callback?: RequestCallback): TRequest;
+
+        put(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        put(uri: string, callback?: RequestCallback): TRequest;
+        put(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+        put(callback?: RequestCallback): TRequest;
+
+        head(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        head(uri: string, callback?: RequestCallback): TRequest;
+        head(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+        head(callback?: RequestCallback): TRequest;
+
+        patch(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        patch(uri: string, callback?: RequestCallback): TRequest;
+        patch(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+        patch(callback?: RequestCallback): TRequest;
+
+        del(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        del(uri: string, callback?: RequestCallback): TRequest;
+        del(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+        del(callback?: RequestCallback): TRequest;
+
+        delete(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+        delete(uri: string, callback?: RequestCallback): TRequest;
+        delete(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+        delete(callback?: RequestCallback): TRequest;
+    }
+
+    interface CoreOptions {
+        baseUrl?: string | undefined;
+        callback?: RequestCallback | undefined;
+        jar?: CookieJar | boolean | undefined;
+        formData?: { [key: string]: any } | undefined;
+        form?: { [key: string]: any } | string | undefined;
+        auth?: AuthOptions | undefined;
+        oauth?: OAuthOptions | undefined;
+        aws?: AWSOptions | undefined;
+        hawk?: HawkOptions | undefined;
+        qs?: any;
+        qsStringifyOptions?: any;
+        qsParseOptions?: any;
+        json?: any;
+        jsonReviver?: ((key: string, value: any) => any) | undefined;
+        jsonReplacer?: ((key: string, value: any) => any) | undefined;
+        multipart?: RequestPart[] | Multipart | undefined;
+        agent?: http.Agent | https.Agent | undefined;
+        agentOptions?: http.AgentOptions | https.AgentOptions | undefined;
+        agentClass?: any;
+        forever?: any;
+        host?: string | undefined;
+        port?: number | undefined;
+        method?: string | undefined;
+        headers?: Headers | undefined;
+        body?: any;
+        family?: 4 | 6 | undefined;
+        followRedirect?: boolean | ((response: http.IncomingMessage) => boolean) | undefined;
+        followAllRedirects?: boolean | undefined;
+        followOriginalHttpMethod?: boolean | undefined;
+        maxRedirects?: number | undefined;
+        removeRefererHeader?: boolean | undefined;
+        encoding?: string | null | undefined;
+        pool?: PoolOptions | undefined;
+        timeout?: number | undefined;
+        localAddress?: string | undefined;
+        proxy?: any;
+        tunnel?: boolean | undefined;
+        strictSSL?: boolean | undefined;
+        rejectUnauthorized?: boolean | undefined;
+        time?: boolean | undefined;
+        gzip?: boolean | undefined;
+        preambleCRLF?: boolean | undefined;
+        postambleCRLF?: boolean | undefined;
+        withCredentials?: boolean | undefined;
+        key?: Buffer | undefined;
+        cert?: Buffer | undefined;
+        passphrase?: string | undefined;
+        ca?: string | Buffer | string[] | Buffer[] | undefined;
+        har?: HttpArchiveRequest | undefined;
+        useQuerystring?: boolean | undefined;
+    }
+
+    interface UriOptions {
+        uri: string | Url;
+    }
+    interface UrlOptions {
+        url: string | Url;
+    }
+    type RequiredUriUrl = UriOptions | UrlOptions;
+
+    type OptionalUriUrl = RequiredUriUrl | {};
+
+    type OptionsWithUri = UriOptions & CoreOptions;
+    type OptionsWithUrl = UrlOptions & CoreOptions;
+    type Options = OptionsWithUri | OptionsWithUrl;
+
+    type MultipartBody = string | Buffer | ArrayBuffer | Uint8Array;
+
+    type RequestCallback = (error: any, response: Response, body: any) => void;
+
+    interface HttpArchiveRequest {
+        url?: string | undefined;
+        method?: string | undefined;
+        headers?: NameValuePair[] | undefined;
+        postData?: {
+            mimeType?: string | undefined;
+            params?: NameValuePair[] | undefined;
+        } | undefined;
+    }
+
+    interface ExtraPoolOptions {
+        maxSockets?: number | undefined;
+    }
+
+    type PoolOptions = false | { [key: string]: http.Agent | https.Agent } & ExtraPoolOptions | ExtraPoolOptions;
+
+    interface NameValuePair {
+        name: string;
+        value: string;
+    }
+
+    interface Multipart {
+        chunked?: boolean | undefined;
+        data?:
+            | Array<{
+                "content-type"?: string | undefined;
+                body: MultipartBody;
+            }>
+            | undefined;
+    }
+
+    interface RequestPart {
+        headers?: Headers | undefined;
+        body: any;
+    }
+
+    interface Request extends caseless.Httpified, Stream {
+        readable: boolean;
+        writable: boolean;
+        explicitMethod?: true | undefined;
+
+        debug(...args: any[]): void;
+        pipeDest(dest: any): void;
+        qs(q: object, clobber?: boolean): Request;
+        form(): FormData;
+        form(form: any): Request;
+        multipart(multipart: RequestPart[]): Request;
+        json(val: any): Request;
+        aws(opts: AWSOptions, now?: boolean): Request;
+        hawk(opts: HawkOptions): void;
+        auth(username: string, password: string, sendImmediately?: boolean, bearer?: string): Request;
+        oauth(oauth: OAuthOptions): Request;
+        jar(jar: CookieJar): Request;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "request", listener: (req: http.ClientRequest) => void): this;
+        on(event: "response", listener: (resp: Response) => void): this;
+        on(event: "data", listener: (data: Buffer | string) => void): this;
+        on(event: "error", listener: (e: Error) => void): this;
+        on(event: "complete", listener: (resp: Response, body?: string | Buffer) => void): this;
+        on(event: "pipe", listener: (src: Readable) => void): this;
+        on(event: "socket", listener: (src: net.Socket) => void): this;
+
+        write(buffer: Buffer | string, cb?: (err?: Error) => void): boolean;
+        write(str: string, encoding?: string, cb?: (err?: Error) => void): boolean;
+        end(cb?: () => void): any;
+        end(chunk: string | Buffer, cb?: () => void): any;
+        end(str: string, encoding?: string, cb?: () => void): any;
+
+        pause(): void;
+        resume(): void;
+        abort(): void;
+        destroy(): void;
+        toJSON(): RequestAsJSON;
+
+        // several of the CoreOptions are copied onto the request instance
+        host?: string | undefined;
+        port?: number | undefined;
+        followAllRedirects?: boolean | undefined;
+        followOriginalHttpMethod?: boolean | undefined;
+        maxRedirects?: number | undefined;
+        removeRefererHeader?: boolean | undefined;
+        encoding?: string | null | undefined;
+        timeout?: number | undefined;
+        localAddress?: string | undefined;
+        strictSSL?: boolean | undefined;
+        rejectUnauthorized?: boolean | undefined;
+        time?: boolean | undefined;
+        gzip?: boolean | undefined;
+        preambleCRLF?: boolean | undefined;
+        postambleCRLF?: boolean | undefined;
+        withCredentials?: boolean | undefined;
+        key?: Buffer | undefined;
+        cert?: Buffer | undefined;
+        passphrase?: string | undefined;
+        ca?: string | Buffer | string[] | Buffer[] | undefined;
+        har?: HttpArchiveRequest | undefined;
+
+        // set in `Request.prototype.init`
+        headers: Headers;
+        method: string;
+        pool: PoolOptions;
+        dests: Readable[];
+        callback?: RequestCallback | undefined;
+        uri: Url & { href: string; pathname: string };
+        proxy: null | string | Url;
+        tunnel: boolean;
+        setHost: boolean;
+        path: string;
+        agent: false | http.Agent | https.Agent;
+        body: Buffer | Buffer[] | string | string[] | Readable;
+        timing?: boolean | undefined;
+        src?: Readable | undefined;
+
+        // set in `Request.prototype.start`
+        href: string;
+        startTime?: number | undefined;
+        startTimeNow?: number | undefined;
+        timings?: {
+            socket: number;
+            lookup: number;
+            connect: number;
+            response: number;
+            end: number;
+        } | undefined;
+
+        // set in `Request.prototype.onRequestResponse`
+        elapsedTime?: number | undefined;
+        response?: Response | undefined;
+    }
+
+    interface Response extends http.IncomingMessage {
+        statusCode: number;
+        statusMessage: string;
+        request: Request;
+        body: any; // Buffer, string, stream.Readable, or a plain object if `json` was truthy
+        caseless: caseless.Caseless; // case-insensitive access to headers
+        toJSON(): ResponseAsJSON;
+
+        timingStart?: number | undefined;
+        elapsedTime?: number | undefined;
+        timings?: {
+            socket: number;
+            lookup: number;
+            connect: number;
+            response: number;
+            end: number;
+        } | undefined;
+        timingPhases?: {
+            wait: number;
+            dns: number;
+            tcp: number;
+            firstByte: number;
+            download: number;
+            total: number;
+        } | undefined;
+    }
+
+    // aliases for backwards compatibility
+    type ResponseRequest = Request;
+    type RequestResponse = Response;
+
+    interface Headers {
+        [key: string]: any;
+    }
+
+    interface AuthOptions {
+        user?: string | undefined;
+        username?: string | undefined;
+        pass?: string | undefined;
+        password?: string | undefined;
+        sendImmediately?: boolean | undefined;
+        bearer?: string | (() => string) | undefined;
+    }
+
+    interface OAuthOptions {
+        callback?: string | undefined;
+        consumer_key?: string | undefined;
+        consumer_secret?: string | undefined;
+        token?: string | undefined;
+        token_secret?: string | undefined;
+        transport_method?: "body" | "header" | "query" | undefined;
+        verifier?: string | undefined;
+        body_hash?: true | string | undefined;
+    }
+
+    interface HawkOptions {
+        credentials: any;
+    }
+
+    interface AWSOptions {
+        secret: string;
+        bucket?: string | undefined;
+    }
+
+    interface RequestAsJSON {
+        uri: Url;
+        method: string;
+        headers: Headers;
+    }
+
+    interface ResponseAsJSON {
+        statusCode: number;
+        body: any;
+        headers: Headers;
+        request: RequestAsJSON;
+    }
+
+    type Cookie = ToughCookie.Cookie;
+
+    interface CookieJar {
+        setCookie(cookieOrStr: Cookie | string, uri: string | Url, options?: ToughCookie.SetCookieOptions): void;
+        getCookieString(uri: string | Url): string;
+        getCookies(uri: string | Url): Cookie[];
+    }
+}
+
+declare var request: request.RequestAPI<request.Request, request.CoreOptions, request.RequiredUriUrl>;
+export = request;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automattic/request-promise-native",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "The simplified HTTP request client 'request' with Promise support. Powered by native ES6 promises.",
   "keywords": [
     "xhr",
@@ -13,11 +13,13 @@
     "native"
   ],
   "main": "./lib/rp.js",
+  "types": "./lib/request.d.ts",
   "scripts": {
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "test": "mocha test/spec",
-    "check-dependencies": "npx depcheck@1.4.7"
+    "check-dependencies": "npx depcheck@1.4.7",
+    "check-dts": "npx check-dts lib/*.d.ts"
   },
   "repository": {
     "type": "git",
@@ -38,9 +40,13 @@
     "stealthy-require": "^1.1.1"
   },
   "devDependencies": {
+    "@types/caseless": "^0.12.5",
+    "@types/node": "^22.13.1",
     "body-parser": "~1.20.3",
     "chai": "^4.5.0",
     "eslint": "^9.19.0",
-    "mocha": "^11.1.0"
+    "globals": "^15.14.0",
+    "mocha": "^11.1.0",
+    "tough-cookie": "^5.1.1"
   }
 }

package/eslint.config.mjs

@@ -1,212 +0,0 @@
-import globals from 'globals';
-
-// https://eslint.org/docs/latest/use/configure/configuration-files#configuration-objects
-export default [{
-    plugins: {},
-
-    languageOptions: {
-        globals: {
-            ...globals.node,
-            ...globals.mocha, // for tests
-            Promise: false
-        },
-
-        ecmaVersion: 2020,
-        sourceType: 'module',
-
-        parserOptions: {
-            ecmaFeatures: {}
-        }
-    },
-
-    rules: {
-        'no-cond-assign': 2,
-        'no-console': 0,
-        'no-constant-condition': 2,
-        'no-control-regex': 2,
-        'no-debugger': 2,
-        'no-dupe-args': 2,
-        'no-dupe-keys': 2,
-        'no-duplicate-case': 2,
-
-        'no-empty': [2, {
-            allowEmptyCatch: false
-        }],
-
-        'no-empty-character-class': 2,
-        'no-ex-assign': 2,
-        'no-extra-boolean-cast': 2,
-        'no-extra-parens': [2, 'all'],
-        'no-extra-semi': 2,
-        'no-func-assign': 2,
-        'no-inner-declarations': [2, 'functions'],
-        'no-invalid-regexp': 2,
-
-        'no-irregular-whitespace': [2, {
-            skipComments: false
-        }],
-
-        'no-negated-in-lhs': 2,
-        'no-obj-calls': 2,
-        'no-prototype-builtins': 2,
-        'no-regex-spaces': 2,
-        'no-sparse-arrays': 2,
-        'no-unexpected-multiline': 2,
-        'no-unreachable': 2,
-        'no-unsafe-finally': 2,
-        'use-isnan': 2,
-        'valid-jsdoc': 0,
-        'valid-typeof': 2,
-        'accessor-pairs': 2,
-        curly: [2, 'multi-line'],
-        'dot-location': [2, 'property'],
-        eqeqeq: 2,
-        'no-caller': 2,
-        'no-empty-pattern': 0,
-        'no-eval': 2,
-        'no-extend-native': 2,
-        'no-extra-bind': 2,
-        'no-fallthrough': 2,
-        'no-floating-decimal': 2,
-        'no-implied-eval': 2,
-        'no-iterator': 2,
-        'no-labels': 2,
-        'no-lone-blocks': 2,
-        'no-magic-numbers': 0,
-        'no-multi-spaces': 2,
-        'no-multi-str': 2,
-        'no-native-reassign': 2,
-        'no-new': 2,
-        'no-new-func': 2,
-        'no-new-wrappers': 2,
-        'no-octal': 2,
-        'no-octal-escape': 2,
-        'no-proto': 2,
-        'no-redeclare': 2,
-        'no-return-assign': [2, 'except-parens'],
-        'no-self-assign': 2,
-        'no-self-compare': 2,
-        'no-sequences': 2,
-        'no-throw-literal': 2,
-        'no-unmodified-loop-condition': 2,
-        'no-useless-call': 2,
-        'no-useless-escape': 2,
-        'no-with': 2,
-        'wrap-iife': [2, 'inside'],
-        yoda: 2,
-        strict: [2, 'safe'],
-        'init-declarations': [2, 'always'],
-        'no-catch-shadow': 0,
-        'no-delete-var': 2,
-        'no-label-var': 2,
-        'no-restricted-globals': 0,
-
-        'no-shadow': [2, {
-            builtinGlobals: false,
-            hoist: 'all',
-            allow: []
-        }],
-
-        'no-shadow-restricted-names': 2,
-
-        'no-undef': [2, {
-            typeof: true
-        }],
-
-        'no-undef-init': 2,
-        'no-undefined': 0,
-
-        'no-unused-vars': [2, {
-            vars: 'local',
-            args: 'none',
-            caughtErrors: 'none'
-        }],
-
-        'no-use-before-define': [2, {
-            functions: false,
-            classes: true
-        }],
-
-        'callback-return': 0,
-        'global-require': 0,
-        'handle-callback-err': [2, '^(err|error)$'],
-        'no-mixed-requires': 0,
-        'no-new-require': 2,
-        'no-path-concat': 2,
-        'no-process-env': 2,
-        'no-process-exit': 2,
-        'no-restricted-modules': 0,
-        'no-sync': 2,
-        'block-spacing': 2,
-
-        'brace-style': [2, '1tbs', {
-            allowSingleLine: true
-        }],
-
-        camelcase: [2, {
-            properties: 'never'
-        }],
-
-        'comma-dangle': [2, 'never'],
-        'comma-spacing': 2,
-        'comma-style': 2,
-        'eol-last': 2,
-
-        indent: [2, 4, {
-            SwitchCase: 1
-        }],
-
-        'jsx-quotes': 0,
-        'key-spacing': 2,
-        'keyword-spacing': 2,
-        'new-cap': 0,
-        'new-parens': 2,
-        'no-array-constructor': 2,
-        'no-mixed-spaces-and-tabs': 2,
-
-        'no-multiple-empty-lines': [2, {
-            max: 2,
-            maxBOF: 0,
-            maxEOF: 1
-        }],
-
-        'no-new-object': 2,
-
-        'no-plusplus': [2, {
-            allowForLoopAfterthoughts: false
-        }],
-
-        'no-spaced-func': 2,
-        'no-trailing-spaces': 2,
-
-        'no-unneeded-ternary': [2, {
-            defaultAssignment: false
-        }],
-
-        'no-whitespace-before-property': 2,
-        'one-var': 0,
-
-        'operator-linebreak': [2, 'after', {
-            overrides: {
-                '?': 'before',
-                ':': 'before'
-            }
-        }],
-
-        'padded-blocks': 0,
-        quotes: [2, 'single', 'avoid-escape'],
-        semi: [2, 'always'],
-        'semi-spacing': 2,
-        'space-before-blocks': 2,
-
-        'space-before-function-paren': [2, {
-            anonymous: 'always',
-            named: 'never'
-        }],
-
-        'space-in-parens': 0,
-        'space-infix-ops': 0,
-        'space-unary-ops': 2,
-        'spaced-comment': 0
-    }
-}];