@derhuerst/http-basic

What is @derhuerst/http-basic?

@derhuerst/http-basic is a lightweight HTTP client for Node.js that provides basic functionalities for making HTTP requests. It is designed to be simple and minimalistic, focusing on ease of use and performance.

What are @derhuerst/http-basic's main functionalities?

Basic GET Request

This feature allows you to make a basic GET request to a specified URL. The response body is logged to the console.

const { request } = require('@derhuerst/http-basic');

const options = {
  method: 'GET',
  url: 'https://jsonplaceholder.typicode.com/posts/1'
};

request(options, (err, res) => {
  if (err) throw err;
  console.log(res.body);
});

Basic POST Request

This feature allows you to make a basic POST request with a JSON body to a specified URL. The response body is logged to the console.

const { request } = require('@derhuerst/http-basic');

const options = {
  method: 'POST',
  url: 'https://jsonplaceholder.typicode.com/posts',
  body: JSON.stringify({ title: 'foo', body: 'bar', userId: 1 }),
  headers: { 'Content-Type': 'application/json' }
};

request(options, (err, res) => {
  if (err) throw err;
  console.log(res.body);
});

Handling Response Headers

This feature allows you to access and log the response headers from a GET request.

const { request } = require('@derhuerst/http-basic');

const options = {
  method: 'GET',
  url: 'https://jsonplaceholder.typicode.com/posts/1'
};

request(options, (err, res) => {
  if (err) throw err;
  console.log(res.headers);
});

Other packages similar to @derhuerst/http-basic

axios

Axios is a promise-based HTTP client for the browser and Node.js. It provides a more feature-rich API compared to @derhuerst/http-basic, including support for interceptors, automatic JSON transformation, and request cancellation.

node-fetch

Node-fetch is a lightweight module that brings `window.fetch` to Node.js. It is similar to @derhuerst/http-basic in terms of simplicity but offers a more modern API that aligns with the Fetch API standard used in browsers.

request

Request is a simplified HTTP client for Node.js with a lot of features. It is more feature-rich than @derhuerst/http-basic but has been deprecated in favor of more modern alternatives like axios and node-fetch.

README

http-basic

This is a temporary fork of ForbesLindesay/http-basic.

---

Simple wrapper arround http.request/https.request

Installation

npm install http-basic

Usage

var request = require('http-basic');

var options = {followRedirects: true, gzip: true, cache: 'memory'};

var req = request('GET', 'http://example.com', options, function (err, res) {
  if (err) throw err;
  console.dir(res.statusCode);
  res.body.resume();
});
req.end();

method:

The http method (e.g. GET, POST, PUT, DELETE etc.)

url:

The url as a string (e.g. http://example.com). It must be fully qualified and either http or https.

options:

• headers - (default {}) http headers
• agent - (default: false) controlls keep-alive (see http://nodejs.org/api/http.html#http_http_request_options_callback)
• duplex - (default: true except for GET, OPTIONS and HEAD requests) allows you to explicitly set a body on a request that uses a method that normally would not have a body
• followRedirects - (default: false) - if true, redirects are followed (note that this only affects the result in the callback)
• maxRedirects - (default: Infinity) - limit the number of redirects allowed.
• allowRedirectHeaders (default: null) - an array of headers allowed for redirects (none if null).
• gzip (default: false) - automatically accept gzip and deflate encodings. This is kept completely transparent to the user.
• cache - (default: null) - 'memory' or 'file' to use the default built in caches or you can pass your own cache implementation.
• timeout (default: false) - times out if no response is returned within the given number of milliseconds.
• socketTimeout (default: false) - calls req.setTimeout internally which causes the request to timeout if no new data is seen for the given number of milliseconds.
• retry (default: false) - retry GET requests. Set this to true to retry when the request errors or returns a status code greater than or equal to 400 (can also be a function that takes (err, req, attemptNo) => shouldRetry)
• retryDelay (default: 200) - the delay between retries (can also be set to a function that takes (err, res, attemptNo) => delay)
• maxRetries (default: 5) - the number of times to retry before giving up.
• ignoreFailedInvalidation (default: false) - whether the cache should swallow errors if there is a problem removing a cached response. Note that enabling this setting may result in incorrect, cached data being returned to the user.
• isMatch - (requestHeaders: Headers, cachedResponse: CachedResponse, defaultValue: boolean) => boolean - override the default behaviour for testing whether a cached response matches a request.
• isExpired - (cachedResponse: CachedResponse, defaultValue: boolean) => boolean - override the default behaviour for testing whether a cached response has expired
• canCache - (res: Response<NodeJS.ReadableStream>, defaultValue: boolean) => boolean - override the default behaviour for testing whether a response can be cached

callback:

The callback is called with err as the first argument and res as the second argument. res is an http-response-object. It has the following properties:

• statusCode - a number representing the HTTP Status Code
• headers - an object representing the HTTP headers
• body - a readable stream respresenting the request body.
• url - the URL that was requested (in the case of redirects, this is the final url that was requested)

returns:

If the method is GET, DELETE or HEAD, it returns undefined.

Otherwise, it returns a writable stream for the body of the request.

Implementing a Cache

A Cache is an object with three methods:

• getResponse(url, callback) - retrieve a cached response object
• setResponse(url, response) - cache a response object
• invalidateResponse(url, callback) - remove a response which is no longer valid

A cached response object is an object with the following properties:

• statusCode - Number
• headers - Object (key value pairs of strings)
• body - Stream (a stream of binary data)
• requestHeaders - Object (key value pairs of strings)
• requestTimestamp - Number

getResponse should call the callback with an optional error and either null or a cached response object, depending on whether the url can be found in the cache. Only GETs are cached.

setResponse should just swallow any errors it has (or resport them using console.warn).

invalidateResponse should call the callback with an optional error if it is unable to invalidate a response.

A cache may also define any of the methods from lib/cache-utils.js to override behaviour for what gets cached. It is currently still only possible to cache "get" requests, although this could be changed.

License

MIT