The Ultimate high-performance HTTP library for WEB

Haikel Fazzani — Sun, 14 Sep 2025 02:21:28 +0000

Tired of wrestling with the limitations of the native fetch API? Meet Stretto, a lightweight, high-performance TypeScript fetch wrapper that brings enterprise-grade resilience and simplicity to your HTTP requests. Built for modern web applications, Stretto combines the elegance of fetch with powerful features like retries, timeouts, and streaming—without the boilerplate.

Why Native Fetch Falls Short

The fetch API is great for quick HTTP requests, but in production, it leaves gaps:

// Basic fetch - looks simple, but what if it fails?
const response = await fetch('https://jsonplaceholder.typicode.com/todos/1');
const data = await response.json();

Real-world challenges like network failures, 503 errors, rate limits, or timeouts can derail your app. Writing custom retry logic, backoff strategies, or stream handling? That’s a lot of code to maintain. Stretto solves these problems while keeping things developer-friendly.

Why Choose Stretto? ✨

Stretto enhances fetch with production-ready features, making your HTTP requests robust, efficient, and easy to use. Here’s what makes it stand out:

🔄 Smart Retries with Exponential Backoff

Handle transient failures like a pro with Stretto’s intelligent retry mechanism:

import stretto from 'stretto';

const response = await stretto('https://jsonplaceholder.typicode.com/todos/1', {
  retries: 5, // Try up to 5 times
  timeout: 10000 // 10-second timeout
});

Stretto uses exponential backoff with jitter to avoid overwhelming servers, ensuring your app stays resilient without flooding recovering endpoints.

⏰ Effortless Timeout Management

Timeouts and cancellations shouldn’t be a headache. Stretto’s createTimeoutController simplifies both:

const controller = new AbortController();
setTimeout(() => controller.abort(), 5000); // Cancel after 5s

const response = await stretto('https://jsonplaceholder.typicode.com/todos/1', {
  signal: controller.signal,
  timeout: 30000 // 30-second timeout
});

Optimized for performance, Stretto minimizes memory leaks and ensures clean cancellation.

🌊 Zero-Copy Streaming for Big Data

Need to process large responses or real-time streams? Stretto’s StrettoStreamableResponse delivers zero-copy streaming for maximum efficiency:

const response = await stretto('https://sse.dev/test', { stream: true });

for await (const chunk of response) {
  processChunk(chunk); // Handle data as it arrives
}

No unnecessary copying, just pure performance.

📡 Seamless Server-Sent Events (SSE)

Real-time apps love Server-Sent Events, but parsing them can be tricky. Stretto’s JSONStreamTransformer makes it a breeze:

import stretto, { JSONStreamTransformer } from 'stretto';

const response = await stretto('https://sse.dev/test', {
  stream: true,
  transformers: [new JSONStreamTransformer({
    maxBuffer: 8192,
    parseData: true,
    onParseError: 'skip'
  })]
});

for await (const event of response) {
  handleRealtimeEvent(event);
}

It’s secure, performant, and handles edge cases like buffer overflows with ease.

🚀 Performance & Security: Built for the Real World

Stretto isn’t just about features—it’s designed for speed and safety:

Memory Efficiency: Zero-copy streaming and buffer reuse keep memory usage low.
Minimal Allocations: Optimized hot paths reduce overhead.
Buffer Overflow Protection: Configurable limits prevent memory exhaustion attacks.
Data Security: Internal buffers are zeroed out to avoid leaks in memory dumps.

Get Started in Minutes! 🛠️

Ready to level up your HTTP requests? Installing Stretto is as easy as:

npm install stretto

Try it with a simple request:

import stretto from 'stretto';

// Quick and simple
const response = await stretto('https://jsonplaceholder.typicode.com/todos');
const data = await response.json();

// Or go robust
const robustResponse = await stretto('https://api.example.com/data', {
  retries: 3,
  timeout: 10000,
  stream: true
});

Why Developers ❤️ Stretto

Familiar API: Builds on fetch, so there’s no steep learning curve.
Production-Ready: Retries, timeouts, and streaming out of the box.
TypeScript-Powered: Full type safety for confident coding.
Lightweight: Minimal footprint, maximum impact.

Join the Stretto Community! 🌟

Stretto is more than a library—it’s a tool to make your apps more reliable and your life easier. Want to dive in?

📦 Install it: npm install stretto
📚 Explore the docs: Stretto GitHub
💬 Share your feedback: Join our community discussions!

Try Stretto in your next project and experience HTTP requests done right. Your users—and your future self—will thank you! 🚀

Simplify OTP Generation with one-time-pass 🔑

Haikel Fazzani — Sun, 31 Aug 2025 02:54:19 +0000

One-Time Passwords (OTPs) are a crucial component of modern authentication systems, providing an extra layer of security through Two-Factor Authentication (2FA).

What is `one-time-pass`?

one-time-pass is a lightweight yet powerful library that generates both TOTP (Time-Based One-Time Password) and HOTP (HMAC-Based One-Time Password) codes. It adheres to the established standards of RFC 6238 and RFC 4226, ensuring that the generated codes are compatible with popular authenticator apps like Google Authenticator.

What makes this library stand out is its commitment to simplicity. With zero dependencies, it keeps your project's footprint small and avoids potential dependency conflicts, making it a great choice for a wide range of applications.

Getting Started: Installation and Usage

To begin using the library in your project, you can install it via npm:

npm i one-time-pass

The library is designed with a modern syntax, making it easy to import and use with ES modules.

Generating a TOTP Code

TOTP codes are the most common type of OTP, relying on the current time and a shared secret key. Here's how you can generate one:

import { generateTOTP } from "one-time-pass";

const secretKey = "your-super-secret-key"; // This key should be unique for each user
const totp = generateTOTP(secretKey, {
  timeStep: 30, // The time step in seconds (default is 30)
  digits: 6, // The number of digits in the OTP (default is 6)
  hash: "sha1", // The hashing algorithm (e.g., "sha1", "sha256", "sha512")
});

console.log(totp); // Outputs a 6-digit TOTP code

Generating an HOTP Code

HOTP codes are counter-based, meaning they change each time the counter is incremented. This is useful for systems where a reliable time source is not available.

import { generateHOTP } from "one-time-pass";

const secretKey = "your-super-secret-key";
const counter = 1234; // The counter value

const hotp = generateHOTP(secretKey, counter, {
  digits: 6,
  hash: "sha1",
});

console.log(hotp); // Outputs a 6-digit HOTP code

Browser Usage

If you're building a client-side application, you can use a CDN to include the library directly via a script tag.

<script src="https://cdn.jsdelivr.net/npm/one-time-pass"></script>
<script>
  // The functions are available globally under the `oneTimePass` object
  const totp = otp.generateTOTP("your-secret-key");
  console.log(totp);
</script>

Conclusion

Whether you're developing for the back end with Node.js or a front-end application, one-time-pass provides a simple, dependable, and efficient way to implement OTP generation. Its zero-dependency approach and adherence to open standards make it an excellent choice for any project that needs robust two-factor authentication without the overhead.

To learn more and contribute, check out the one-time-pass GitHub repository.

DEV Community: Haikel Fazzani