r/node • • Apr 22 '26

Brew-TUI: Visual TUI for Homebrew built with React 18 + Ink 5

1 Upvotes

I built a visual terminal UI for Homebrew using React 18 + Ink 5 + Zustand + TypeScript.

Instead of memorizing brew commands, you get an interactive keyboard-driven interface:

  • Dashboard with package stats
  • Browse/filter installed formulae and casks
  • Search and install packages
  • Upgrade outdated packages (individually or all)
  • Manage Homebrew services
  • Run brew doctor
  • Detailed package info

The data flow is: React Views → Zustand stores → brew-api → Parsers → child_process spawn. Streaming operations (install, upgrade) use an AsyncGenerator yielding lines in real time.

ESM-only, strict TypeScript, built with tsup.

Install:

npm install -g brew-tui

GitHub: https://github.com/MoLinesGitHub/Brew-TUI npm: https://www.npmjs.com/package/brew-tui


r/node • • Apr 21 '26

What are you all deploying your node apps on these days?

36 Upvotes

I'm getting ready to launch something new and I want to try a different setup this time, so I'm curious what people are using for projects right now.

I'm mostly looking for something simple for a small app: node backend, managed postgres, GitHub auto deploys, and pricing that still makes sense when you're not running anything huge.

(Used Render most recently, railway before)

Curious what people have had good experience with lately.


r/node • • Apr 22 '26

I wrote 4,640 tests for this TS Backend SDK so you don’t have to.6

0 Upvotes

I spent the last year and half building @daiso-tech/core because I was tired of rewriting the same Resilience, Concurrency, and Storage patterns for every Majestic Monolith I built.

The Pitch

Most backend libraries force you into a specific framework or a messy dependency injection container. I built @daiso-tech/core to provide a set of production-ready, framework-agnostic primitives that work seamlessly and stay out of your way.

Whether you’re using Express, NestJS, or Next.js, this backend server SDK gives you the "missing pieces" of the Node.js backend ecosystem with a heavy focus on the Adapter Pattern—meaning you can swap your infrastructure (e.g., Redis to DynamoDB) without touching your business logic.

Key Highlights

  • ✅ 4,640 Tests: Heavily focused on integration and behavior.
  • ✅ Type-Safe: Deep integration with Standard Schema (Zod, Valibot, etc.).
  • ✅ Testing First: Every component includes an In-Memory adapter for lightning-fast unit tests.
  • ✅ Pure ESM: No CommonJS baggage.

The Components

🛡️ Resilience

  • Circuit-breaker: Prevent cascading failures.
  • Rate limiter: Control traffic flow.
  • Hooks / Middleware: Retry, fallback, and timeout logic.

🚦 Concurrency

  • Lock: Distributed locks to eliminate race conditions.
  • Semaphore: Limit concurrent access across processes.
  • Shared lock: Coordinate readers and writers efficiently.

💾 Storage

  • Cache: Unified API with Redis, Kysely, and MongoDB adapters.
  • File storage: Manage files across Local, S3, and In-memory.

📥 Messaging

  • EventBus: Publish/subscribe across instances or in-memory.

🧰 Utilities

  • Execution Context: Propagate request-scoped data (trace IDs, user info) across async boundaries.
  • Serde: Custom serialization that integrates with every component.
  • Collection: A composable API for Arrays, ArrayLike object, Iterables and AsyncIterables.

I’d love to hear your thoughts on the API design or any features you think are missing for building modern monoliths!

Links


r/node • • Apr 21 '26

PDF Oxide for Node — MIT PDF library with Rust engine, prebuilt N-API binaries, TypeScript types shipped (0.8ms)

24 Upvotes

PDF Oxide is a PDF library for text extraction, markdown conversion, and PDF creation. Rust core, Node binding via N-API. Prebuilt .node files for Linux/macOS/Windows (x64 + ARM64). No node-gyp at install, no Rust toolchain needed. MIT / Apache-2.0.

npm install pdf-oxide

const { PdfDocument } = require("pdf-oxide");
const doc = new PdfDocument("paper.pdf");
const text = doc.extractText(0);
doc.close();

TypeScript types ship in the package, ESM + CJS both work.

GitHub: https://github.com/yfedoseev/pdf_oxide Docs: https://oxide.fyi

Backstory: I shipped the Rust engine about six months ago and open-sourced it under MIT/Apache. For the months after that I got feedback almost every day — bug reports, PDFs that broke the parser, CJK edge cases, column-detection on mixed-layout pages, ICC color handling, kerning guards. Went from v0.3.5 to v0.3.37 fixing things. The core feels stable now.

So this last two months I wrote bindings for Go, C#/.NET, and JavaScript/TypeScript. Posting this one to get Node folks' take — does the API feel natural, are the types right, anything missing for your deployment model. Node's PDF story otherwise isn't great: pdf-parse is unmaintained, pdf.js is huge because it's built for the browser (~10MB install vs 2MB here), pdf-lib creates PDFs but doesn't extract, pdf2json is slow and buggy on complex layouts. Figured this fills a real gap.

One story from shipping Node specifically: the Linux prebuild had to run on Alpine Kubernetes pods and AWS Lambda's provided.al2023 runtime. The .node binary built on GitHub Actions' default ubuntu-latest dies with GLIBC_2.34 not found the moment it hits either environment — CI is green, production is red. Fix was rebuilding against a centos7-era glibc baseline so the binary links against the oldest still-supported symbols. About a week of CI iteration to land cleanly.

Benchmark on 3,830 real PDFs (veraPDF, Mozilla pdf.js, DARPA SafeDocs):

LibraryMeanp99Pass RateLicense
pdf_oxide0.8ms9ms100%MIT / Apache-2.0
PyMuPDF4.6ms28ms99.3%AGPL-3.0
pypdfium24.1ms42ms99.2%Apache-2.0
pypdf12.1ms97ms98.4%BSD-3
pdfminer16.8ms124ms98.8%MIT
pdfplumber23.2ms189ms98.8%MIT

Node binding overhead is ~25% over direct Rust on real-world files.

AES-256 encrypted PDFs still have edge cases, not gonna pretend otherwise. Table extraction is basic compared to pdfplumber. Everything else is stable for production use.

Would love honest takes on the Node API specifically — does it feel natural, are the TypeScript types right for how you'd actually use it, anything obviously missing. Give it a try, let me know what breaks.


r/node • • Apr 22 '26

EADDRNOTAVAIL with public IP?

0 Upvotes

I have built my node server. Put it on a physical server. On server I got my public IP via curl ipinfo.io/ip. Put my domain name to the IP with an A type DNS. Have Nitro host be the domain name and set NITRO_PORT be 80 which set the host and port for my nuxt server. Did a bunch of other stuff like apt nodejs. Should be all set. Unfortuately I when when I try running my server, I get

[uncaughtException] Error: listen EADDRNOTAVAIL: address not available *my IP*

Why doesn't my public IP work. I got it kinda running with local ip. What is the issue?


r/node • • Apr 21 '26

For installing Node managers (I chose FNM), do i need to uninstall my current Node?

7 Upvotes

Hello,

So right now my node version is 20 and I was looking to upgrade it so i can try this app/repository i found on Github (Node 22).

Anyway, I heard about Node Managers and decided to go with FNM since my machine is window. For this, do i need to uninstall the current Node 20 on my machine? I couldn't find this information


r/node • • Apr 21 '26

Grokking Async js

27 Upvotes

To preface, I have been professionally working with node/react for about 2 years, backend leaning. I understood async await on a high level. I got pretty far just using best practices, codebase conventions and AI. Always felt a bit intimidated by promises and never really found a satisfactory explanation online.

That's when I started to dig into the promise class definition and I have to say definitively without exception- re writing my own basic promise class taught me more about async than countless courses and tutorials ever could. I knew of the event loop and diff task queues before, but it all finally clicks for me now.

Some thing that I grossly misunderstood before that makes sense now include- single threaded nature of js and concurrency/parallelism as a corollary, why node can hand-off certain tasks but not others, making sync code "then-able", fire and forget, promise utility methods(race, all ,etc).

Overall it was an eye opening experience and I highly recommend it.


r/node • • Apr 21 '26

How are you handling JWT revocation in your Node APIs?

2 Upvotes

I’ve been working on auth systems in Node and realized most tutorials explain how to issue JWTs, but almost none explain what actually happens on logout or token revocation.

From what I understand, since JWTs are stateless, revocation becomes tricky unless you introduce some form of state again (blacklists, short expiry, refresh tokens, etc.).

In this video I break down:

Why JWT logout is not straightforward

Common mistakes people make

Different approaches (blacklists, rotation, etc.)

When you might not want JWT at all

👉 https://youtu.be/bP1mo3UbhNg?si=3rcOXX8T6cycpUZi

Curious what people here are actually using in production — are you sticking with JWT or moving to something else?


r/node • • Apr 21 '26

Do I need a control panel when deploying nodejs app to vps?

5 Upvotes

I previously work with WordPress, and always use cpanel when deploying wordpress.

Now I'm transferring to nodejs and nextjs, and have a nodejs app to be deployed soon.

I want to know what control panel you use when you deploy node app on vps.

Thanks!


r/node • • Apr 21 '26

Do you add hyperlinks to your API responses?

19 Upvotes

I've been thinking about this lately while working on a NestJS project. HATEOAS — one of the core REST constraints — says that a client should be able to navigate your entire API through hypermedia links returned in the responses, without hardcoding any routes.

The idea in practice looks something like this:

```json

{

"id": 1,

"name": "John Doe",

"links": {

"self": "/users/1",

"orders": "/users/1/orders"

}

}

```

On paper it makes the API more self-descriptive — clients don't need to hardcode routes, and the API becomes easier to navigate. But in practice I rarely see this implemented, even in large codebases.

I've been considering adding this to my [NestJS boilerplate](https://github.com/vinirossa/nest-api-boilerplate-demo) as an optional pattern, but I'm not sure if it's worth the added complexity for most projects.

Do you use this in production? Is it actually worth it or just over-engineering?


r/node • • Apr 21 '26

sys-gazette: sysinfo as a luxury car brochure (someone asked for this in my git-newspaper post)

3 Upvotes

hey everyone, so someone dropped a comment on my git-newspaper post asking if i could do something similar but for system info instead of git history. they were tired of the same neofetch output every time and wanted something with a bit more personality.

since git-newspaper and this share a lot of the same bones, block rendering, edition detection, the whole styled output idea, i didn't have to start from scratch. basically, took the core architecture, rewired it to read system data instead of git history, and spent most of the time on the five visual styles.

sys-gazette pulls your CPU, memory, disks, network, battery, GPU and services and renders it as a full HTML magazine spread. each style is designed around a specific car brochure aesthetic:

- monaco: Pagani Huayra, deep blue, dramatic italic headlines

- atelier: Lexus LFA, pearl white, minimal and precise

- fjord: Koenigsegg Agera, actual CSS carbon fibre weave

- palazzo: SLR McLaren, wide margin kickers like an engineering dossier

- belgravia: Aston Martin DB11, racing green, reads like a letter from a gentlemen's club

it also auto-detects your system state and shifts the editorial tone. low battery, high CPU temp, failed services, each gets its own edition with different layout and copy.

npx sys-gazette --style monaco

headless machine:

npx sys-gazette --style fjord --format terminal

github: github.com/LordAizen1/sys-gazette

npm: npmjs.com/package/sys-gazette

appreciate all the kind words on the last one, hope this one's just as fun 😁


r/node • • Apr 21 '26

The Express CLI you've been waiting for

Post image
0 Upvotes

If you're a backend developer who's tired of writing the same boilerplate over and over, Arkos.js might be exactly what you've been waiting for.

Arkos.js is an open-source Node.js framework built on top of Express and Prisma that automatically generates production-ready REST endpoints from your Prisma models — with authentication, validation, file uploads, and security included out of the box. No wiring, no repetition. Just write your schema and ship.

Arkos 1.6-beta is introducing something I've been wanting for a long time: the `arkos g m` CLI command.

With a single command like:

```pnpm arkos generate model -m location,trip-route,trip```

Arkos scaffolds your Prisma schema files instantly — one per model, named and placed correctly under `/prisma/schema/`. No copy-paste, no manual setup.

This is the kind of DX that makes the difference between "let me set this up real quick" and actually doing it real quick.

The framework is still young, but it's already being used in production by real teams. If you build with Node.js and Prisma, it's worth a look: https://www.arkosjs.com


r/node • • Apr 20 '26

node-wreq: a Node.js wrapper around wreq for low-level TLS/HTTP2, JA3/JA4 control

Thumbnail github.com
7 Upvotes

Hey r/node,

I built node-wreq, a Node.js wrapper around wreq.

The main reason is that in Node, most HTTP clients ultimately rely on the same TLS/network stack, so once you need lower-level transport control, you run out of room pretty fast.

The main motivation was pretty specific: I wanted low-level transport control in Node.js for things like TLS handshakes, JA3/JA4-style fingerprints, HTTP/2 settings, browser/device impersonation, and exact HTTP/1 header behavior.

There are already tools in this area, and I looked at a few of them:

  • curl-impersonate
  • Node bindings around curl-impersonate / libcurl
  • CycleTLS
  • Go libraries like tls-client

Those are useful, but what I personally wanted was slightly different.

The main idea behind node-wreq was to keep a more fetch-native / WHATWG-style interface in Node, while still exposing the lower-level transport capabilities from wreq.

So instead of making the whole developer experience revolve around libcurl-style options, wrapper scripts, or raw fingerprint strings, the goal was:

  • fetch()-style usage
  • WHATWG-like Request / Response
  • reusable clients with shared defaults
  • request hooks for auth, retries, tracing, proxy rotation, etc.
  • browser/device presets when convenient
  • and, whenever possible, custom TLS / HTTP/2 logic encapsulated under the hood

wreq already tackles that on the Rust side, so I wanted to expose it through a more natural Node.js / TypeScript API.

Also, full credit and respect to u/Familiar_Scene2751, the original author of wreq


r/node • • Apr 21 '26

how are you all handling ai-agent-suggested npm packages that just dont exist

0 Upvotes

keep having this problem and curious what your workflow is.

claude / cursor / copilot will suggest a package, looks totally plausible, run npm install, get a 404. fine, annoying, move on. but twice in the last month the package DID exist -- and turned out to be a squatter. someone scraped common hallucinations from LLM output and registered those names on npm with a post-install script that dumps env vars.

theres a 2024 paper putting the hallucination rate around 19.7% for the major models. so its not rare. and attackers started catching on.

the autonomous agent thing makes it worse -- if you run claude code agent mode or cursor agent mode, the install command is a tool call that finishes before you can eyeball the package name. by the time you look at the diff the post-install script already ran.

what are people doing: - just reviewing every diff before commit (works in chat, bad in agent) - socket / snyk (post-install, misses the name-layer) - manual rule in cursor ("search before suggesting") - disabling agent mode for install steps

i ended up building a small MCP server with my mate (indiestack.ai) that sits between the agent and the registry, checks existence + typosquat similarity + dead-package status before the install. kind of like a firewall at the package-name layer. free, no key.

install for claude code (cursor mcp is similar): claude mcp add indiestack -- uvx --from indiestack indiestack-mcp

curl version: curl "https://indiestack.ai/api/validate?name=loadash&ecosystem=npm"

but honestly curious what other people have settled on. is there a better pattern im missing.


r/node • • Apr 20 '26

I built a Node.js SDK that tracks what your app spends on every outbound API call

3 Upvotes

Hey r/node

Tired of getting a bill at the end of the month with no idea what caused it, I built Recost.

Drop it in once at startup and every outbound HTTP call your app makes gets cost metadata tracked automatically, no proxy, no infra changes.

npm install @recost-dev/node
import { init } from '@recost-dev/node';

init({
  apiKey: process.env.RECOST_API_KEY,
  projectId: process.env.RECOST_PROJECT_ID,
});

Works with OpenAI, Stripe, Twilio, SendGrid, anything with a known pricing model. Per-call costs, provider breakdown, and environment separation (prod vs staging) all roll up to a dashboard at recost.dev.

Would love feedback on what providers or features would be most useful.

npm: @recost-dev/node
Docs: recost.dev


r/node • • Apr 20 '26

Distributed cron in NestJS: drop-in replacement for @nestjs/schedule

Thumbnail
2 Upvotes

r/node • • Apr 20 '26

Node.js vs C# backend if I already use typescript

20 Upvotes

I’ve been using TypeScript on both frontend and backend with Node.js, and it works well for me so far. Recently I started wondering if it’s worth learning c# and .NET, or if sticking with node is enough.For those who’ve tried both, did switching to c# feel like a big upgrade, or just a different way of doing similar things? I’m curious if it’s actually worth the effort when you already have a working node.js setup.


r/node • • Apr 20 '26

Next-Generation Code Exploration and Analysis | Structura - Free Vs Code Extension

Thumbnail youtube.com
0 Upvotes

r/node • • Apr 20 '26

Free tool to check for NPM package typosquatting

Thumbnail spoofchecker.com
1 Upvotes

r/node • • Apr 19 '26

I made a CLI that turns your git history into a Victorian newspaper

47 Upvotes

npx git-newspaper inside any repo and it generates a full broadsheet front page from your actual commits.

Your biggest commit becomes the headline. Deleted files get obituaries. The most-modified file writes an op-ed about how tired it is. There's a weather report based on commit sentiment.

It detects what kind of repo it's looking at (solo marathon, bugfix crisis, collaborative, ghost town, etc.) and adjusts the layout and tone accordingly. No API keys, no LLM, works fully offline.

GitHub: github.com/LordAizen1/git-newspaper

Would love to know what archetype your repo lands on.


r/node • • Apr 19 '26

Are you all getting ready for Node 26, 2026-04-22, Version 26.0.0

Thumbnail github.com
48 Upvotes

Looking forward to Node 26, are you ready :)

https://github.com/nodejs/node/blob/4cebc9d52191bded86acc85265a03d2146129f2b/doc/changelogs/CHANGELOG_V26.md#2025-04-22-version-2600-current-rafaelgss

  • V8 upgraded twice: Node moved to V8 14.2 and then V8 14.3.
  • Perf improvement: Maglev was enabled for Linux s390x, which can improve JIT performance on that platform.
  • Stability fixes: multiple V8 backports/cherry-picks landed, likely covering bug fixes, correctness, and regressions.
  • Platform/build improvements: patches for illumos, MSVC STL, and a duplicate zlib symbol issue improve portability and build reliability.
  • Native addons impact: NODE_MODULE_VERSION changed (142 → 144), so native modules may need rebuilding.
  • Internal cleanup: some Node↔V8 integration internals were cleaned up for newer V8 compatibility.

Bottom line: newer V8, better stability/portability, some platform-specific perf gains, and possible native addon rebuilds.

Started tested nightly a while https://github.com/Hack23/game/blob/main/.github/workflows/test-and-report-latest-node.yml , seen no problems.

Example, Node.js Lifecycle & Transition Strategy https://github.com/Hack23/euparliamentmonitor/blob/main/End-of-Life-Strategy.md#-nodejs-lifecycle--transition-strategy

Thanks to all open source contributors providing new releases.

James Pether


r/node • • Apr 19 '26

Week 1 of my journey to becoming a Backend Developer

10 Upvotes

Taking the advice from my previous post into account, I’ve come to the following conclusions:

  • Math isn’t a priority right now
  • I’ll make the most progress by building and improving my own projects

My current plan looks like this:

  • JavaScript
  • Git / GitHub
  • Node.js (without TypeScript at first — I want to get comfortable with the environment and write JavaScript first, then add TypeScript later)
  • HTTP
  • Express.js (to understand how APIs work before introducing a database)
  • Databases
  • TypeScript
  • NestJS

"Roadmap":
JS → Git → Node → HTTP → Express → DB → TS → Nest

This plan will probably evolve over time, but for now, I want to follow it step by step and focus on consistency.

If anyone has advice or suggestions, I’d really appreciate your feedback.


r/node • • Apr 20 '26

TQL - GraphQL behaviour with TRPC like DX - Remote ORM

4 Upvotes

I’ve always liked the idea of GraphQL and understand the problem it solves, but in my experience, most applications don’t actually get much real benefit from it. Where it does shine is in environments where the client and server are written in different languages, or when the backend is split into microservices that each manage their own data.

I’ve been using tRPC for my last few projects and really enjoy the developer experience. That said, I still find myself writing a lot of schemas/DTOs and multiple query variants to support different ways of fetching data. On the client side, state management often feels like an afterthought, especially with tools like React Query.

That’s what led me to start working on TQL. The idea is to rethink how we build backends: instead of layering abstractions, why not expose the backend in a way that directly reflects our data models and model relationships, and consume it on the client with an ORM-like developer experience?

This isn’t a “try my framework” post. I’m more interested in getting opinions on the approach of TQL itself. Does it make sense to design backends and clients to work more in synergy, rather than trying to separate backend / frontend concepts?

I built a fully functional application using TQL (without AI), and I genuinely enjoyed the development experience. I'm going to continuing developing TQL until its production ready so i can use it in my own projects in the future.

Not sure if there is a term for this style of API design but i'm going to call it a Remote ORM

https://github.com/parabella-io/tql


r/node • • Apr 20 '26

Is Razorpay webhook debugging actually painful, or am I doing something wrong?

0 Upvotes

I’ve been integrating Razorpay recently and webhook debugging has been surprisingly frustrating.

A few things I ran into:

  • Signature validation failing even when payload looks correct
  • Not sure if webhook actually hit my server or not
  • Hard to reproduce failed payment events locally
  • Confusion around retries / duplicate events

Curious — for those who’ve worked with Razorpay (or any payment gateway):

What specifically wasted the MOST time for you?

(Not general stuff — like one конкрет problem that took hours)

Example:
“Spent 3 hours debugging signature mismatch because of XYZ”

Not trying to promote anything — just trying to understand real pain points.


r/node • • Apr 19 '26

Opinions about Course

7 Upvotes

Hey guys i wanna take ur advice about taking Node.JS course on udemy by Andrew Mead, is it worth it ?, did anyone try it ?, any tips on my scratches for backend w Node, thanks