Bent HTTP Client

Common errors

• ERR_REQUIRE_ESM

  cause Attempting to `import bent from 'bent'` in a Node.js project configured with `"type": "module"` in `package.json`.
  fix Change the import to `const bent = require('bent');` or use a dynamic import `const bent = await import('bent');` and then access `bent.default || bent` for the actual function.

• Status code 404 not acceptable

  cause The HTTP response had a status code (e.g., 404 Not Found) that was not explicitly listed as an acceptable status code when the `bent` instance was created.
  fix Modify your `bent` factory call to include all expected successful status codes, e.g., `bent(200, 201, 404)` if 404 is an expected, handled case.

• Error: Response body is not JSON

  cause The `bent` instance was configured with `'json'` as the response format, but the server responded with non-JSON content or an empty body.
  fix Ensure the server is sending `Content-Type: application/json` and valid JSON. If the content type varies, create `bent` instances that don't specify a response format (`bent()`) and use `response.json()` conditionally, or `bent('string')` for text responses.

• Cannot read property 'buffer' of undefined

  cause Trying to use `.buffer()` or `.json()` methods on the raw response object when the `bent` instance was *not* configured for a specific response type, and the method might not exist or be appropriate.
  fix If you need a specific format (like `buffer` or `json`), configure your `bent` instance with that format (e.g., `const getBuffer = bent('buffer');`). If not, handle the raw Node.js stream or use the `.arrayBuffer()`/`.text()`/`.json()` methods provided on the response object (matching Fetch API) after checking its type or status.

Warnings

• breaking Bent requires explicit declaration of *all* acceptable status codes. If you provide any status codes, `200` must be explicitly included if you want it to be acceptable. By default, only `200` is acceptable unless overridden.
  Fix: Ensure all expected successful status codes, including `200`, are passed to the `bent` factory function, e.g., `bent(200, 201)`.
• gotcha When sending `form-urlencoded` data, Bent does not automatically encode the body or set the `Content-Type` header. You must manually encode the body (e.g., using `URLSearchParams` or `form-urlencoded` package) and set the `Content-Type` header to `application/x-www-form-urlencoded`.
  Fix: Use `const postForm = bent('POST', { 'Content-Type': 'application/x-www-form-urlencoded' }); await postForm(url, new URLSearchParams({ key: 'value' }).toString());`
• gotcha Bent uses Node.js `Buffer` for binary data in Node.js environments and `ArrayBuffer` (or `ArrayBufferView` types like `UInt8Array`) in browser environments. Mixing these types or assuming `Buffer` is globally available in browsers will lead to errors.
  Fix: Always check the environment and use the appropriate binary type. In Node.js, `Buffer.from('data')`; in browser, `new TextEncoder().encode('data')` for `ArrayBufferView` or `new ArrayBuffer(...)`.
• gotcha Bent v7 primarily ships as a CommonJS module for Node.js. Direct `import bent from 'bent'` statements in pure Node.js ESM projects will result in `ERR_REQUIRE_ESM` errors unless transpiled or configured via `type: 'module'` with appropriate `require` shims.
  Fix: In Node.js ESM projects, if a `bent` ESM build isn't available or preferred, use dynamic `import('bent').then(m => m.default || m)` or consider a CommonJS wrapper. For browser, bundling typically handles ESM imports correctly.

Install

• npm install bent npm
• yarn add bent yarn
• pnpm add bent pnpm

Imports

• bent
  wrong:

  import bent from 'bent'

  correct:

  const bent = require('bent')

  Bent v7 is primarily a CommonJS module for Node.js. While bundlers can handle ESM imports for browser targets, attempting `import bent from 'bent'` in a pure Node.js ESM project will typically result in an error like `ERR_REQUIRE_ESM`.
• getJSON

  const getJSON = bent('json', 'GET');

  When using Bent, you first create a 'bent instance' with desired default options (like response format, method, base URL, accepted status codes) and then call that instance for specific requests.
• bent
  wrong:

  const bent = require('bent'); // For browser builds

  correct:

  import bent from 'bent'; // When used in browser via a bundler

  For browser applications, Bent is typically bundled, and an ESM import `import bent from 'bent'` is common as bundlers will correctly resolve the browser-specific module entry point. `require` is not standard in browser environments.

Quickstart

Demonstrates creating different `bent` instances for GET (JSON) and POST (JSON) requests, and fetching binary data as a buffer, with error handling.

const bent = require('bent');

async function fetchData() {
  try {
    // Create a bent instance for GET requests expecting JSON and 200 OK
    const getJSON = bent('GET', 'json', 200);
    // Create a bent instance for POST requests expecting 201 Created and JSON input/output
    const postJSON = bent('POST', 'json', 201);

    console.log('Fetching public JSON data...');
    const publicData = await getJSON('https://jsonplaceholder.typicode.com/todos/1');
    console.log('Public Data:', publicData);

    console.log('\nPosting new data...');
    const newData = { title: 'foo', body: 'bar', userId: 1 };
    // Using a fake API endpoint that always returns 201 for POST
    const postResponse = await postJSON('https://jsonplaceholder.typicode.com/posts', newData);
    console.log('Post Response:', postResponse);

    // Example of fetching a buffer (e.g., an image, though this is a text file)
    const getBuffer = bent('GET', 'buffer', 200);
    console.log('\nFetching a text file as buffer...');
    const buffer = await getBuffer('https://jsonplaceholder.typicode.com/todos/1'); // Fetching same data but as buffer
    console.log('Buffer content start:', buffer.toString().substring(0, 50), '...');

  } catch (error) {
    console.error('An error occurred:', error.message);
    if (error.statusCode) {
      console.error('Status Code:', error.statusCode);
    }
    if (error.text) {
        const errorBody = await error.text();
        console.error('Error Body:', errorBody);
    }
  }
}

fetchData();