Request Promise Core

Common errors

• Error: Cannot find module 'request'

  cause The 'request' package is defined as a peer dependency, meaning it must be installed separately by the consumer project, but it was not.
  fix Install the 'request' package: `npm install --save request`.

• TypeError: request(...).then is not a function

  cause The 'request' instance was not properly patched by `request-promise-core`, or an unpatched 'request' instance was used. This often happens if `require('request')` is called directly before `request-promise-core` has a chance to apply its patches.
  fix Ensure `request-promise-core`'s `configure` function is called to patch `request`, and that `request` is loaded using `stealthyRequire` as recommended in the documentation to avoid using an unpatched instance.

• TypeError: PromiseImpl must be a thenable constructor

  cause The `PromiseImpl` option passed to the `configure` function was either missing or not a valid ES6-compatible Promise constructor.
  fix Ensure `PromiseImpl: Promise` (for native Promises) or a specific Promise library constructor (e.g., `PromiseImpl: Bluebird`) is provided to the `configure` function.

Warnings

• breaking The underlying 'request' library, which this package extends, was officially deprecated on February 11, 2020. This means 'request-promise-core' and its dependents (like 'request-promise') are also effectively abandoned and should not be used in new projects. Consider migrating to modern alternatives like Axios, `node-fetch`, or `undici`.
  Fix: Migrate away from 'request-promise-core' and the 'request' ecosystem entirely. Recommended alternatives include Axios, `node-fetch`, or the built-in `fetch` API in Node.js >= 18.
• gotcha Directly using `require('request')` before patching its prototype with `request-promise-core` can lead to an unpatched 'request' instance being used by other parts of your application. The README explicitly recommends using `stealthy-require` to prevent such conflicts.
  Fix: Always load `request` via `stealthy-require` as shown in the package's usage example to ensure a consistent, patched instance across your application: `const request = stealthyRequire(require.cache, () => require('request'));`
• deprecated The 'request@next' branch for the 'request' library never fully materialized or reached a stable release. Consequently, the configuration helper `require('request-promise-core/configure/request-next')` is obsolete and should not be used.
  Fix: Avoid using `request-promise-core/configure/request-next`. Stick to `request-promise-core/configure/request2` for compatibility with `request@^2.34`, though migration away from the entire ecosystem is strongly advised.
• gotcha This library is explicitly designed as a core component for other `request-promise` packages and is 'only recommended to use this library directly, if you have very specific requirements.' Most users should have used `request-promise` directly, which itself is now deprecated.
  Fix: If encountering this package as a direct dependency, reassess the need. It's almost certainly part of a deprecated chain. Migrate to a modern HTTP client.

Install

• npm install request-promise-core npm
• yarn add request-promise-core yarn
• pnpm add request-promise-core pnpm

Imports

• configure
  wrong:

  import configure from 'request-promise-core/configure/request2';

  correct:

  const configure = require('request-promise-core/configure/request2');

  This package primarily uses CommonJS `require` syntax. The 'configure' function is the main entry point to add Promise capabilities to a 'request' instance.
• stealthyRequire
  wrong:

  import stealthyRequire from 'stealthy-require';

  correct:

  const stealthyRequire = require('stealthy-require');

  Used in the recommended pattern to safely load and patch the 'request' library without interfering with other 'request' consumers in the same application. This is a CommonJS module.
• request
  wrong:

  const request = require('request');

  correct:

  const request = stealthyRequire(require.cache, function () { return require('request'); });

  Directly `require('request')` before patching can lead to issues if other parts of the application also use 'request'. The `stealthy-require` pattern is recommended to ensure the Promise-enhanced version is used consistently.

Quickstart

This quickstart demonstrates how to apply Promise capabilities to the 'request' library using `request-promise-core`, including safe loading with `stealthy-require` and basic error handling.

const stealthyRequire = require('stealthy-require');
const request = stealthyRequire(require.cache, function () {
    return require('request');
});

const configure = require('request-promise-core/configure/request2');

configure({
    request: request,
    PromiseImpl: Promise,
    expose: [
        'then',
        'catch',
        'promise'
    ],
    constructorMixin: function (resolve, reject) {
        // `this` is the request object
    }
});

// 3. Use request with its promise capabilities

request('https://api.example.com/data')
    .then(function (body) {
        console.log('Received data:', body.substring(0, 100) + '...');
    })
    .catch(function (err) {
        console.error('Request failed:', err.message);
    });

// Example with environment variable for a real API call (mocked here)
const API_KEY = process.env.EXAMPLE_API_KEY ?? 'MOCK_API_KEY';
request(`https://api.example.com/secure-data?key=${API_KEY}`)
    .then(function (body) {
        console.log('Secure data access successful (mocked):', body.substring(0, 100) + '...');
    })
    .catch(function (err) {
        console.error('Secure data access failed (mocked):', err.message);
    });