Requestify - Node HTTP Client with Caching

Common errors

• Error: Cannot find module 'requestify'

  cause The package `requestify` is not installed or the `require()` path is incorrect.
  fix Ensure `requestify` is listed in your `package.json` dependencies and installed via `npm install` or `yarn install`. Verify the `require('requestify')` statement is correct.

• TypeError: requestify.get is not a function

  cause The `requestify` module was not successfully loaded or the object is not the expected Requestify instance. This can happen with incorrect `require()` usage or if a different module is aliased as `requestify`.
  fix Confirm `const requestify = require('requestify');` executed without error. Check for any naming conflicts in your scope that might be overwriting the `requestify` variable.

• UnhandledPromiseRejectionWarning: DeprecationWarning: A promise was rejected with a non-error: [object Object]

  cause This warning, often seen in older Node.js versions or with specific promise libraries like Q, indicates that a promise rejected with a value that is not an `Error` object, or that a promise rejection was not caught.
  fix Always reject promises with `new Error('message')` instead of plain strings or objects. Ensure all promises have a `.fail()` or `.then(null, onRejected)` handler to catch rejections. Upgrade Node.js if possible, as this warning might be indicative of other compatibility issues.

• ReferenceError: Promise is not defined

  cause This error occurs in very old Node.js environments where native ES6 `Promise` is not globally available, or if transpilation targets an environment without `Promise`.
  fix While `requestify` uses `Q` promises (which does not depend on native `Promise`), attempting to use native `Promise` methods without a polyfill in old Node.js (~0.10.x) would cause this. Ensure you are exclusively using `Q`'s promise API or explicitly polyfill `Promise` if mixing.

Warnings

• breaking Requestify requires Node.js version ~0.10.x. It is largely incompatible with modern Node.js versions (v12+). Running it on newer Node.js runtimes will likely result in unexpected behavior or errors due to API changes and removed core modules.
  Fix: This package is not recommended for new projects. Consider modern alternatives like `axios`, `node-fetch`, or `undici`. For existing projects, consider a shim or a rewrite, as upgrading Node.js is critical for security and performance.
• gotcha Requestify uses the 'Q' promise library for asynchronous operations, not native ES6 Promises. Developers expecting native Promise behavior (e.g., `catch()` instead of `fail()`, `finally()`) or interoperability might encounter issues.
  Fix: Be mindful of Q's API for promises, including `.then(onFulfilled, onRejected)` and `.fail(onRejected)` for error handling. Avoid mixing with native Promises unless using `Q.fcall(asyncFn)` to wrap native async functions.
• deprecated The `requestify.redis(redisInstance)` method is deprecated. Users should instead configure the Redis cache transporter directly via `requestify.cacheTransporter(requestify.coreCacheTransporters.redis(myRedisInstance));`.
  Fix: Replace calls to `requestify.redis()` with `requestify.cacheTransporter(requestify.coreCacheTransporters.redis(myRedisInstance));` for proper configuration and future compatibility.
• gotcha The Requestify project appears to be abandoned. Its last publish date was 9 years ago (2016), and it targets a very old Node.js engine (~0.10.x). This means it receives no security updates, bug fixes, or new features.
  Fix: Do not use Requestify for new projects. For existing projects, migration to a maintained HTTP client is strongly advised to avoid security vulnerabilities and ensure compatibility with modern infrastructure.
• gotcha Requestify lacks native TypeScript support and modern JavaScript features (e.g., `async/await` syntax, `fetch` API alternatives). This can lead to less ergonomic code and challenges in TypeScript-first projects.
  Fix: Consider using a modern HTTP client designed for TypeScript and contemporary JavaScript, which provides type definitions and supports modern language features out-of-the-box.

Install

• npm install requestify npm
• yarn add requestify yarn
• pnpm add requestify pnpm

Imports

• requestify
  wrong:

  import requestify from 'requestify';

  correct:

  const requestify = require('requestify');

  Requestify is a CommonJS module and must be imported using `require()`. ESM imports will not work.
• requestify.get
  wrong:

  requestify().get('http://example.com');

  correct:

  requestify.get('http://example.com').then(...);

  HTTP methods are directly available on the default exported `requestify` object.
• requestify.coreCacheTransporters
  wrong:

  import { coreCacheTransporters } from 'requestify';

  correct:

  const coreCacheTransporters = requestify.coreCacheTransporters;

  Nested properties like `coreCacheTransporters` are accessed via the main `requestify` object, not through named ESM imports.

Quickstart

This quickstart demonstrates basic GET and POST requests, shows how to set encoding, and illustrates the use of Requestify's built-in caching mechanism with the default in-memory transporter. It highlights the promise-based nature of the API using the `then` method.

const requestify = require('requestify');

async function performRequests() {
  // Set a custom encoding (optional, utf8 is default)
  requestify.setEncoding('utf8');

  // Example GET request
  console.log('Performing GET request...');
  try {
    const getResponse = await requestify.get('https://httpbin.org/get').then(function(response) {
      return response.getBody(); // Q-promise .then()
    });
    console.log('GET Response Body:', getResponse);
  } catch (error) {
    console.error('GET Error:', error.message || error.code || error);
  }

  // Example POST request with JSON body
  console.log('\nPerforming POST request...');
  try {
    const postResponse = await requestify.post('https://httpbin.org/post', {
      hello: 'world',
      timestamp: new Date().toISOString()
    }).then(function(response) {
      return response.getBody(); // Q-promise .then()
    });
    console.log('POST Response Body:', postResponse);
  } catch (error) {
    console.error('POST Error:', error.message || error.code || error);
  }

  // Example GET request with caching enabled (requires cache transporter setup)
  console.log('\nPerforming cached GET request...');
  // Using the default in-memory cache transporter
  const coreCacheTransporters = requestify.coreCacheTransporters;
  requestify.cacheTransporter(coreCacheTransporters.inMemory());
  try {
    const cachedGetResponse = await requestify.get('https://httpbin.org/delay/1', { 
      cache: { cache: true, expires: 5000 } // Cache for 5 seconds
    }).then(function(response) {
      return response.getBody();
    });
    console.log('Cached GET Response Body (first call):', cachedGetResponse);

    // Immediately fetch again, should be from cache if within 5 seconds
    const cachedGetResponse2 = await requestify.get('https://httpbin.org/delay/1', { 
      cache: { cache: true, expires: 5000 } 
    }).then(function(response) {
      return response.getBody();
    });
    console.log('Cached GET Response Body (second call, should be fast):', cachedGetResponse2);
  } catch (error) {
    console.error('Cached GET Error:', error.message || error.code || error);
  }
}

performRequests();