Teepee HTTP Client

3.0.1 · abandoned · verified Wed Apr 22

Teepee is a generic HTTP client for Node.js, currently at version 3.0.1. It provides basic functionality for making HTTP requests, akin to older-generation clients. The package has seen no significant code updates in approximately seven years, with its latest npm publication dating back five years (v3.0.1). This indicates the library is effectively abandoned and unmaintained. Unlike actively developed modern HTTP clients such as Axios or Node-Fetch, Teepee lacks native TypeScript support, a clear release cadence, and up-to-date documentation on its feature set or breaking changes between major versions. Its primary differentiator is its lightweight nature and adherence to older Node.js conventions for HTTP requests.

Common errors

```
TypeError: teepee is not a function
```
cause Attempting to call 'teepee' directly after an incorrect CommonJS `require('teepee').default` or incorrect named ESM import `import { teepee } from 'teepee'`.

fix For CommonJS, use `const teepee = require('teepee');`. For ESM, use `import teepee from 'teepee';`.
```
UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch().
```
cause Teepee's request methods likely return Promises, but the consuming code does not include proper error handling (e.g., `try...catch` or `.catch()`).

fix Always wrap `await teepee(...)` calls in a `try...catch` block or chain a `.catch()` method to the promise returned by `teepee` to handle network errors or API responses indicating failure.

Warnings

breaking The `teepee` package is effectively abandoned. The last major code change was seven years ago, and the last npm release (v3.0.1) was five years ago. This means there will be no further updates, bug fixes, or security patches.
Fix: Migrate to a currently maintained HTTP client library (e.g., `axios`, `node-fetch`, or native `fetch` API in Node.js 18+). Evaluate all dependencies for security vulnerabilities.
gotcha The library lacks official TypeScript type definitions. Developers using TypeScript will need to create their own declaration files (`.d.ts`) or rely on `@ts-ignore`, which can lead to type-related errors and reduced developer productivity.
Fix: Consider creating a `teepee.d.ts` file with basic type declarations for common usage patterns or, preferably, migrate to a library with robust TypeScript support.
breaking There is no clear changelog or migration guide available for breaking changes between major versions, specifically from v2 to v3. Transitioning existing code between these versions without official documentation can lead to unexpected behavior and require significant code review.
Fix: Thoroughly review the source code and run comprehensive regression tests if upgrading from a v2 version. The recommended fix is to avoid this library and use a maintained alternative.
gotcha Being unmaintained, `teepee`'s internal dependencies are likely outdated and contain known or undiscovered security vulnerabilities. Using it in production environments poses a significant supply chain risk.
Fix: Conduct a security audit of `teepee`'s transitive dependencies using tools like `npm audit` and manually verify the status of critical dependencies. Prioritize migration to a well-maintained and secure HTTP client.

Install

npm install teepee npm
yarn add teepee yarn
pnpm add teepee pnpm

Imports

teepee
wrong:
```
import { teepee } from 'teepee';
```
correct:
```
import teepee from 'teepee';
```
While typically used with CommonJS `require`, a default import is likely for ESM environments given its age and common patterns for 'main' function exports.
teepee (CommonJS)
```
const teepee = require('teepee');
```
This is the most common and expected import pattern for a package of this era and status. The primary export is likely a function or an object with methods.

Quickstart

Demonstrates how to perform a basic GET request to an example API endpoint using Teepee, handling headers and potential stream-based responses. It assumes an asynchronous function for fetching data.

import teepee from 'teepee';

async function fetchData() {
  try {
    const response = await teepee('https://api.example.com/data', {
      method: 'GET',
      headers: {
        'Accept': 'application/json',
        'Authorization': `Bearer ${process.env.API_KEY ?? ''}`
      },
      // Assuming basic response handling, library might return data directly or require stream processing
      // Depending on actual implementation, may need .text() or .json() equivalent.
      // For this example, we assume it's a simple function returning a readable stream or Promise<Response>
      // and data is collected/parsed separately.
      // This example implies a body property if it returns a stream/buffer.
    });

    // In a real scenario for teepee, you would likely need to consume the response stream:
    let data = '';
    for await (const chunk of response) {
      data += chunk.toString();
    }
    console.log('Fetched data:', data);

  } catch (error) {
    console.error('Error fetching data:', error.message);
  }
}

fetchData();

view raw JSON →