DEV Community: Sanjeev

I rebuilt the HTTP client setup I copy-paste into every project — into one package

Sanjeev — Sat, 13 Jun 2026 08:49:51 +0000

Every project starts the same way. You reach for axios. Then reality sets in:

npm install axios
# ...then axios-retry for retry logic
# ...then axios-cache-interceptor for caching
# ...then you discover a circuit breaker just doesn't exist
# ...then you wrap every single call in try/catch
# ...then you realize WebSocket, SSE, and GraphQL aren't included either

ky? Lovely, but browser-only by design — no circuit breaker, no offline queue, no GraphQL, no Result.

I got tired of reassembling the same resilience stack on every project, so I built it once: reixo — an HTTP client that ships complete.

npm install reixo

No peer dependencies. Runs unchanged on Node.js 20+, Bun, Deno, Cloudflare Workers, Vercel Edge, and browsers.

The one idea that changed how I write request code

reixo returns errors as values, not exceptions. The try* methods give you a "Result", and TypeScript won't let you touch the data until you've handled the error branch:

import { HTTPClient } from 'reixo';

const client = new HTTPClient({
  baseURL: 'https://api.example.com/v1',
  retry: true,            // 3 retries, exponential backoff, 5xx / 429 / 408
  circuitBreaker: true,   // open after 5 failures, reset after 30s
  cacheConfig: true,      // in-memory LRU, 5 min TTL
  enableDeduplication: true,
});

const result = await client.tryGet<User>('/users/1');

if (!result.ok) {
  return handleError(result.error); // fully typed HTTPError
}

console.log(result.data.name); // TypeScript knows the type here

No try/catch. No "did I remember to handle the 500?" An entire class of runtime errors just disappears.

What "ships complete" actually means

All of this is in the box — zero extra installs:

Result API — tryGet, tryPost, etc. force you to handle both branches
Resilience stack — retry w/ backoff, circuit breaker (with half-open probing), rate limiter, offline queue — configured in one place
Request deduplication — three simultaneous GETs to the same URL share one round-trip
Caching — LRU memory + localStorage/sessionStorage, cache-first / network-first / stale-while-revalidate
Real-time transports — typed WebSocket client (reconnect + heartbeat) and SSE client
GraphQL client — queries, mutations, Automatic Persisted Queries
Zero-dependency OpenTelemetry — W3C traceparent, no OTEL SDK
Data utilities — infinite query, cursor pagination, priority task queue with persistence, resumable chunked upload
Dev ergonomics — fluent HTTPBuilder, MockAdapter for tests, NetworkRecorder for fixtures

How it stacks up

A real example: poll a job until it's done

import { poll } from 'reixo';

const { promise, cancel } = poll(() => client.get<Job>('/jobs/42'), {
  interval: 2_000,
  until: (res) => res.data.status === 'done',
  timeout: 120_000,
});

const result = await promise;

No hand-rolled setInterval, no leak-prone cleanup. Built in.

Try it

npm install reixo

📦 npm: https://www.npmjs.com/package/reixo
⭐ GitHub: https://github.com/webcoderspeed/reixo

It's MIT, TypeScript-first, Node 20+. I'm building in public — if you try it, tell me what your "copy-paste into every project" HTTP setup looks like. That's exactly the gap I'm trying to close.

I got tired of re-installing 6 logging packages in every project, so I built one that ships complete

Sanjeev — Sat, 13 Jun 2026 08:43:51 +0000

Every new Node project, the same ritual:

npm install pino pino-pretty pino-roll pino-redact pino-nestjs pino-http

Then you wire up 4 config objects. Then you discover there's no built-in database transport. Then request tracing turns out to be manual. Then — under real I/O pressure — your logger is blocking the event loop.

I did this enough times that I built the thing I kept wishing existed: logixia — an async-first TypeScript logger that ships complete.

npm install logixia

One install gives you: console + file rotation + database transports + request tracing + a NestJS module + field redaction + log search + OpenTelemetry + a plugin API + Prometheus metrics + a visual TUI log explorer — and every transport is non-blocking.

The 30-second version

import { createLogger } from 'logixia';

const logger = createLogger({
  appName: 'api',
  environment: 'production',
  transports: {
    console: { format: 'json' },
    file: { filename: 'app.log', dirname: './logs', maxSize: '50MB' },
    database: { type: 'postgresql', host: 'localhost', database: 'appdb', table: 'logs' },
  },
});

await logger.info('Server started', { port: 3000 });
// Writes to console + file + postgres simultaneously. Non-blocking. Done.

No try/catch needed — a flaky DB or disk-full condition never crashes your app; transport errors are swallowed internally.

Why I went "batteries-included"
console.log doesn't scale. pino is fast but leaves database persistence, NestJS integration, log search, and redaction to plugins. winston is flexible but synchronous and boilerplate-heavy.

logixia's bet: everything ships built-in, and nothing blocks your event loop.

A few of the things that come in the box:

Async by design — every log call is non-blocking, even to file and DB transports
Built-in database transports — PostgreSQL, MySQL, MongoDB, SQLite
Cloud adapters — AWS CloudWatch (with EMF metrics), GCP Logging, Azure Monitor
NestJS module — LogixiaLoggerModule.forRoot(), inject anywhere, @LogMethod() for auto entry/exit logging
Request tracing — AsyncLocalStorage-based trace propagation, no manual context threading
Correlation ID propagation — auto-forward X-Correlation-ID through fetch, axios, Kafka, SQS
Field redaction — mask passwords/tokens/PII before they touch any transport (dot-paths + regex)
Browser/Edge/Bun/Deno — tree-shakeable logixia/browser entry, zero Node built-ins
Prometheus metrics — turn log events into counters/histograms/gauges, expose /metrics
Visual TUI explorer — logixia explore opens a full-screen terminal log browser with real-time search

"But is it actually fast?"

Fair question for an async-first logger. Benchmarked against pino, winston, and bunyan (all writing to /dev/null, Node 20, Apple M-series; ops/sec, higher is better):

logixia beats pino on 5 of 6 scenarios — including +114% on error logging and +58% on high-cardinality — the shapes that dominate real production traffic. It beats winston and bunyan across the board, often 2–3×, while keeping p99 latency at 1–3µs with no tail spikes.

pino still wins the trivial simple-string case (−14%) because it writes synchronously straight to process.stdout — fast in a microbenchmark, but it blocks the event loop under real I/O. logixia stays non-blocking and pulls ahead the moment you log anything structured.

(Reproduce with npm run benchmark.)

Try it

npm install logixia

📦 npm: https://www.npmjs.com/package/logixia
⭐ GitHub: https://github.com/Logixia/logixia

It's MIT, TypeScript-first, Node 18+. I'm building in public — if you try it, I'd genuinely love to know what you'd want a logger to do that none of them do today. That's how the next version gets shaped.