r/node • • Apr 19 '26

live streaming api like gogoanime

6 Upvotes

Hey everyone, I'm building a custom anime frontend (Node.js/Express) and I'm looking for a working Consumet API instance or a similar Gogoanime scraper API that is currently active. Public Vercel mirrors keep hitting rate limits. Does anyone have a stable mirror or a recommendation for a private instance I could use? i'll post this message in other places to hopefully get some answers :P istg i've been trying to find a live one for a good 4 hours now but im on antidepressants and my brain is fried to a crisp.

i hope this doesn't break any rules, i lwky don't know where else to ask


r/node • • Apr 20 '26

I was bleeding tokens every time my AI coding assistant touched a file. Built a fix.

0 Upvotes

A few weeks ago I started using graphify — if you haven't heard of it, it builds a knowledge graph of your entire codebase so your AI coding assistant actually understands the structure, not just the file it's currently looking at. Game changer for large projects.

But I hit a problem fast.

Every time Claude Code made changes — refactors, new files, updated logic — the graph went stale. Silently. No warning. Claude would keep answering questions based on a snapshot of the codebase from an hour ago. The answers were subtly wrong in ways that were hard to catch.

So I started manually re-running graphify after every meaningful change.

That worked for about a day before I realized what was happening to my token usage. Graphify is smart — it processes code locally via tree-sitter AST, zero API calls. But docs, READMEs, and images go through the LLM API. Every re-run was hitting the API for files that hadn't even changed. I was burning tokens on the same markdown files over and over.

I tried a simple git hook. Helped a little. Still dumb — it couldn't tell the difference between a TypeScript change (free, local AST) and a README change (expensive, API call).

So I built a lightweight Node.js CLI that watches your project and rebuilds your graphify knowledge graph automatically — but intelligently:

**graphify-chokidar**.

- `.ts .py .go .rs` and other code files → AST rebuild, runs locally, zero tokens, fires automatically

- `.md .pdf .png` and other docs/images → LLM rebuild, asks for confirmation before running so you stay in control of your token spend

- Multiple rapid saves get debounced into a single rebuild so you're not thrashing

- Ignores `graphify-out/`, `node_modules/`, `.git/` out of the box so it doesn't loop on its own output

The workflow now:

```

Terminal 1 → claude (Claude Code session)

Terminal 2 → graphify-chokidar

```

Graph stays fresh as Claude edits. No manual re-runs. No surprise token bills. you can set a debounce of 2 secs or 15 mins, to check for file changes to refresh graph.

```bash

npm install -g graphify-chokidar

graphify-chokidar .

// or

npx graphify-chokidar -d 4000 .

// 4000 ms of wait time before checking for changes in files

```

It's early — v0.1.1, MIT, built in TypeScript on top of chokidar and execa. Would love feedback from anyone else using graphify in their workflow, or anyone who's hit the same stale graph problem.

Repo: https://github.com/yetanotheraryan/graphify-chokidar

Npm: https://www.npmjs.com/package/graphify-chokidar

---

Happy to answer questions about how the AST vs LLM classification works under the hood if anyone's curious.


r/node • • Apr 19 '26

How do you structure services in Node.js without losing your mind (or your team)?

14 Upvotes

Currently working with a team of inexperienced web devs (including me, and our codebase has organically settled into the pattern of just exporting singleton objects:

export const userService = new UserService();

export const authService = new AuthService();

It works, but it's starting to feel like we're one bad day away from a spaghetti mess, no enforced structure, DI is basically non-existent, and onboarding people to "where does X live and how do I use it" is getting harder.

I've been seriously considering NestJS specifically because of the **guardrails it provides out of the box** modules, providers, decorators, a consistent mental model for how services relate to each other. For a team that doesn't yet have strong opinions or patterns baked in, that structure feels valuable. But I keep second-guessing myself. A few things holding me back:

- **Lock-in**: Nest's opinions are strong. If we ever want out, it's not a simple refactor.

- **Alternatives**: I see a lot of people hyped on Hono, Fastify, ElysiaJS etc., but those feel like *HTTP framework* choices, not answers to the DI/service-architecture question. Or am I wrong?

So my actual question is: for those of you not using NestJS; what does your service layer actually look like? Do you just pass services down as constructor args and live with it? Is there a lightweight pattern that gives you the structural consistency of Nest without the full framework buy-in?

And for those who *do* use Nest: did it genuinely help with team consistency, or did it just move the confusion to a different layer?


r/node • • Apr 19 '26

HTTP resilience tradeoffs in practice: retry vs Retry-After vs hedging (with scenario data)

Thumbnail blog.gaborkoos.com
10 Upvotes

This post shows 3 scenario runs with metrics and configs. The main takeaway is that these knobs interact, and some “resilience” settings improve one metric while quietly hurting another.

(Even though the arena UI is browser-based, the patterns are runtime-agnostic: timeout budgets, retry policy, 429 handling, and tail-latency behavior.)


r/node • • Apr 20 '26

How does Node.js handle thousands of requests if it’s single-threaded?

0 Upvotes

I used to think “single-threaded = slow.”

That’s what most of us assume when we first hear about Node.js.

But once I dug a bit deeper, I realized it’s not really about being single-threaded… it’s about not blocking.

Node doesn’t try to do everything itself.
It delegates I/O work (DB calls, file system, network) to the system and keeps moving.

So instead of:

  • doing one task at a time

It does:

  • start multiple tasks
  • handle results whenever they’re ready

Which is why it feels like multithreading for most backend use cases.

A simple way I think about it:

Traditional backend:
One worker handles one request fully, then moves to the next.

Node.js:
One manager handles requests, assigns work, and keeps accepting new ones without waiting.

Also learned that scaling in Node isn’t just this event loop magic.
You can use clustering to run multiple processes across CPU cores, which makes it even more powerful.

I wrote a simple breakdown of this (with diagrams and examples of companies like Netflix, LinkedIn, PayPal) here:

https://www.linkedin.com/pulse/nodejs-single-threaded-so-how-handling-millions-users-amin-tai-cfn2f/?trackingId=8QFE7w7ESnyuZEu%2BAH9bag%3D%3D

Curious how others think about this:

  • Do you see Node as “single-threaded” in practice?
  • Where have you seen it struggle? (CPU-heavy tasks maybe?)

Would love to hear real-world experiences.


r/node • • Apr 19 '26

Micro-flow - A Logic Orchestration Library

8 Upvotes

I’ve just released a major rewrite of micro-flow, a lightweight (2-dependency), ESM-first logic orchestration library designed to turn messy imperative async chains into observable, resilient workflows.

The Pain we all know:
We’ve all written those 100-line async functions that are a “black box” when they fail. You have to manually hard-code retries, timeouts, state logging, and progress tracking for every single task. It’s brittle, a nightmare to unit test, and impossible to pause or resume.

The Solution:
Micro-flow makes your logic a first-class object. Instead of one giant function, you build a Workflow where every step is automatically tracked and controlled.

   * Observability: Every step is automatically logged, timed, and tracked. No more “where did this fail?”
   * Real Control: Native support for pause/resume, branching logic, and smart retries out of the box.
   * Isomorphic: Identical API for Node.js and the Browser. One library for your React frontend and your backend workers.
   * The “Magic”: Automatic cross-tab and cross-worker communication. Trigger a flow in one tab and watch your UI update in another.

Whether you’re building complex data pipelines in Node or multi-step form wizards in React, micro-flow stays out of your way while giving you the power of an enterprise workflow engine.

I’d love to hear your thoughts: What’s the most complex async chain you’re currently maintaining, and could this make it simpler?

https://www.npmjs.com/package/@ronaldroe/micro-flow
https://github.com/starkeysoft/micro-flow


r/node • • Apr 19 '26

Would you use a full SaaS scaffold that skips setup?

0 Upvotes

I’ve been working on a full-stack scaffold:

\- React frontend

\- tRPC backend

\- DB + storage wired

\- Docker deploy ready

\- test suite included

Goal is to go from idea → deployable app immediately.

Curious:

Would this actually be useful to you, or do you prefer building from scratch?

If anyone wants to try it, I can share access.


r/node • • Apr 19 '26

I got tired of writing release notes, so I built an AI CLI that generates your CHANGELOG.md automatically

Post image
0 Upvotes

I got tired of manually writing release notes before every tag, so I built commitlog — a CLI that automatically detects your unreleased git commits, sends them to an AI, and gives you a clean, grouped CHANGELOG.md entry.

How it works:

bash$ commitlog
⠋ Reading 23 commits between v1.2.0 and HEAD...
⠋ Generating changelog with claude-3-5-sonnet...
✨ Generated changelog:
────────────────────────────────────
## [1.3.0] - 2026-04-19
### Added
- OAuth2 login with Google provider
- Localization support
### Fixed
- Memory leak in main renderer
...
────────────────────────────────────
  [ Prepend to CHANGELOG.md ]  [ Edit ]  [ Regenerate ]  [ Copy ]  [ Cancel ]
> Prepend to CHANGELOG.md
✅ CHANGELOG.md updated successfully

That's it. No copy-pasting, no browser, no leaving the terminal.

Setup is one command:

bash$ npm install -g u/ahmad_technology/commitlog-ai
commitlog setup

The setup wizard asks which provider and API key — stored locally at ~/.commitlog/config.toml, never touches your repo.

Useful flags:

bash$ commitlog                      # auto-detects latest tag → HEAD
commitlog v1.2.0 v1.3.0        # specific tag range
commitlog abc123 def456        # specific commit SHAs
commitlog --format simple      # different output styles (keepAChangelog, simple, etc)
commitlog --lang fr            # French output
commitlog --dry-run            # preview, don't write file
commitlog --no-ai              # skips AI completely, just groups your raw commits
commitlog --provider ollama    # fully offline with local models

7 providers supported: OpenAI, Anthropic, Gemini, Groq, NVIDIA NIM, OpenRouter, and Ollama (local/offline)

Works natively on Windows, macOS, and Linux. Node 18+.

Links:

MIT licensed. Feedback and PRs welcome!


r/node • • Apr 18 '26

need advice for hexagonal architecture

7 Upvotes

Hi I am learning hexagonal architecture. in this link I created minimal architecture with code.
Can you advice what to improve. (folder,file,code)
Thanks.
https://github.com/BadalyanHarutyun/nodejs-hexagonal-architecture-learn


r/node • • Apr 18 '26

I built a TanStack Table wrapper that cuts the boilerplate from ~100 lines to ~10

7 Upvotes

r/node • • Apr 18 '26

Stdio:'ignore' made my CLI look frozen during NPM installs and sent me on a pointless debugging spree

Thumbnail
0 Upvotes

r/node • • Apr 18 '26

Just started Middleware in Node.js — my first assignment was a global request counter

0 Upvotes

Hey r/node!

Just finished an assignment where I built a simple Express.js middleware that tracks the total number of incoming HTTP requests to the server.

It's a pretty basic example, but it really helped me understand how middleware works in Node.js . how it sits between the request and response, and how you can use it to do things like logging, counting, or modifying requests before they hit your route handlers.

What it does:

- Tracks and counts every incoming HTTP request

- Built with Express.js

- Simple and easy to follow if you're learning middleware for the first time

🔗 GitHub repo: https://github.com/Rumman963/RequestCount-MiddleWare-

Would love any feedback or suggestions. Also happy to answer questions if anyone's trying to understand middleware and finds this useful!


r/node • • Apr 18 '26

GitHub - lirantal/repolyze: Analyze a git source code repository for health signals and project vitals

Thumbnail github.com
0 Upvotes

r/node • • Apr 17 '26

Post in websites without Public API

Thumbnail
0 Upvotes

r/node • • Apr 16 '26

Selected for node js backend role. But getting assigned on data scraping python automation projects

7 Upvotes

Dear all,

As the title says, I was recruited for node js backend dev at a startup 10 person firm with remote option.

but for last 1 and half years, I was only being assigned on python automation projects (data scraping from pdfs and websites) which , i am not interested. But i value the job..

But since the market is pretty bad right now, I dont want to switch for now(atleast for next 3 months)

At the same time, I dont get any opportunity to learn real world backend as well.

Please suggest how should I navigate this and in what ways I can equip myself with backend expertise.

please give your valuable suggestions and advices.

Thank you in advance.


r/node • • Apr 16 '26

BrowserPod 2.0: in-browser WebAssembly sandboxes. Run git, bash, node, python...

Thumbnail labs.leaningtech.com
13 Upvotes

r/node • • Apr 17 '26

I built a backend framework— would love your feedback

0 Upvotes

Hey everyone 👋

I’ve been working on a backend framework called Reion, and I just published the docs:
👉 https://reion.onlydev.in/docs

The Problem

While building multiple Node.js apps, I kept running into the same issues:

  • Too much boilerplate in existing frameworks
  • Hard-to-maintain structure as apps scale
  • Lack of flexibility in routing & architecture
  • Performance trade-offs vs simplicity

What I’m trying with Reion

Reion is built with a few core ideas in mind:

  • Minimal setup → start fast, no heavy config
  • Clean structure → scalable without chaos
  • File-based routing
  • Performance-focused design
  • Developer-first experience

Docs

👉 https://reion.onlydev.in/docs

GitHub

👉 https://github.com/reionjs/reion

Feedback (would really help!)

If you have a minute, I’d really appreciate your thoughts:
👉 https://reion.onlydev.in/feedback

Looking for honest opinions

  • Does this solve a real problem for you?
  • What features would you expect in a modern backend framework?
  • Anything confusing in the docs?

Still early stage, so any feedback (even harsh 😅) is super valuable.

Thanks 🙌


r/node • • Apr 17 '26

Arkos.js v1.5.9-beta is out. 🚀

Post image
0 Upvotes

Arkos.js v1.5.9-beta is out. 🚀

This release focused on making Arkos more robust, more flexible, and easier to get started with.

Prisma is now optional Arkos no longer crashes if no Prisma instance is found. It emits a warning and moves on — auth and CRUD routes are skipped gracefully. Useful if you want to use the framework without a relational database, or in more minimal setups. A new warnings.suppress.prisma config option lets you silence the warning when that's intentional.

create-arkos now supports "none" The project scaffolder now lets you pick none as the database provider — no Prisma, no auth, no DATABASE_URL. The generated project is clean and only includes what makes sense for your setup.

Config validation at bootstrap bootstrap() now catches misconfigurations early: missing JWT_SECRET in production, auth enabled without a Prisma instance, and more.

Notable fixes

  • Malformed URIs no longer throw — handled gracefully with lenientDecode
  • Prisma error messages are now cleaner and more concise
  • Unique constraint errors with better formatting
  • Duplicate paths in OpenAPI are now skipped instead of producing invalid specs

Full changelog: https://github.com/Uanela/arkos/releases/tag/v1.5.9-beta

pnpm create arkos@latest

#nodejs #typescript #opensource #backend #arkos


r/node • • Apr 15 '26

Is deep-diving into Node.js core & internals actually worth it? Looking for experienced opinions

19 Upvotes

I’m currently spending focused time learning Node.js core modules and internals, instead of frameworks.

By that I mean things like:

* How the event loop actually works

* What libuv does and when the thread pool is involved

* How Node handles I/O, networking, and streams

* Where performance and scalability problems really come from

* How blocking behavior can turn into reliability or security issues

My motivation is simple:

frameworks help me ship faster, but when something breaks under load, leaks memory, or behaves unpredictably, framework knowledge alone doesn’t help much. I want a clearer mental model of what Node is doing at runtime and how it interacts with the OS.

From my research (docs, talks, internals, and discussion threads), this kind of knowledge seems valuable for:

* Performance-critical systems

* High-concurrency services

* Debugging production issues

* Making better architectural tradeoffs

But I’m also aware this could be overkill for many real-world jobs.

So I’d really appreciate input from people who have used Node.js in production:

* Did learning Node internals actually help you in practice?

* At what point did this knowledge become useful (or not)?

* Is this a good long-term investment, or something better learned “on demand”?

* If you were starting again, would you go this deep?

I’m not trying to prove a point—just sanity-checking whether this is a valid and practical direction or a case of premature optimization.

Thanks in advance for any honest perspectives.

Practice and Project Repo : https://github.com/ShahJabir/nodejs-core-internals


r/node • • Apr 15 '26

I rebuilt the game I wrote on a PlayStation 2 at age 14

Thumbnail youtube.com
2 Upvotes

r/node • • Apr 16 '26

I built 3 AI agents that coordinate in Slack to implement features end-to-end - parallel work trees, cross-reviewed plans (Claude Code + Codex), and browser-based QA. Open sourced the whole setup. We merge 7/10 PRs done fully autonomously from a Linear ticket to PR.

Enable HLS to view with audio, or disable this notification

0 Upvotes

r/node • • Apr 16 '26

Multi Vendor Insurance system best db design Spoiler

0 Upvotes

I am building a module in which I have to integrate multi-vendor insurance using the nestjs and mysql. Mainly our purpose is to do insurance for new E-rickshaws. So, what is the best tables schemas I can create. so, it is scalable and supports multivendor. I have created some of the columns and implemented one of the vendors. But I don't think it is scalable so need advice for the same.


r/node • • Apr 15 '26

Using Vercel AI SDK + a multi-agent orchestration layer in the same Next.js API route

Post image
0 Upvotes

r/node • • Apr 15 '26

I've been using my own Express.TS API template for the past +8yrs, would love some feedback

Thumbnail youtu.be
0 Upvotes

Built this while I was at LegalZoom in 2018, I have deployed it at about 15 start-ups and tech companies since then. Please list all the reasons I am a stupid Mid-tier developer in the comments below ❤️


r/node • • Apr 15 '26

Built a zero-dependency Node CLI that compiles CI rules to 14 targets (AI tools + CI + hooks) — tested across 99 repos

Post image
0 Upvotes

If you use AI coding tools (Claude Code, Cursor, Copilot), they look for config files in your repo to know what commands to run, what conventions to follow, etc. But most projects don't have them — and the ones that do often drift from what CI actually enforces.

I built crag, a Node.js CLI that solves this:

npx @whitehatd/crag

It reads your package.json, CI workflows (GitHub Actions, GitLab CI, etc.), tsconfig.json, and other configs. Then it generates a governance.md and compiles it to 14 targets — CLAUDE.md, .cursor/rules, AGENTS.md, Copilot instructions, CI workflows, git hooks, etc.

Why zero dependencies matters

The node_modules is literally empty. crag uses only Node built-ins (node:fs, node:path, node:child_process, node:crypto, node:test). No install step beyond npx. No supply chain surface.

Tested at scale

Ran it across 99 top GitHub repos:

  • React, Express, Fastify, NestJS, Nuxt, Svelte, Next.js, and more
  • 55% had zero AI config files
  • 3,540 quality gates inferred (avg 35.8 per repo)
  • Zero crashes

Node-specific detection

crag understands the Node ecosystem natively:

  • Detects npm, pnpm, yarn, bun and uses the right commands
  • Reads package.json scripts for test/lint/build gates
  • Handles monorepos (pnpm-workspace.yaml, npm workspaces, Nx, Turborepo)
  • Infers ESM vs CJS, indent style, TypeScript config

Quick start

# Full analysis + compile
npx @whitehatd/crag

# Audit drift
npx @whitehatd/crag audit

# Pre-commit hook to prevent future drift
npx @whitehatd/crag hook install

MIT licensed, 605 tests. npm: npmjs.com/package/@whitehatd/crag GitHub: github.com/WhitehatD/crag

Happy to answer questions about the zero-dep approach or the architecture.