Is There a CabloyJS Equivalent in the React/Next.js Ecosystem?

In the Node.js fullstack world, CabloyJS has always occupied a rather specific position. It is not a "frontend framework with some API routes on the side," but an enterprise fullstack architecture with module boundaries, built-in IoC (inversion of control / dependency injection), native RBAC and Workflow, and a metadata contract shared by frontend and backend.

So a familiar question comes up: if a team's stack is React/Next.js, is there something "close enough"?

The short answer: there is no exact equivalent to CabloyJS. What the React/Next.js ecosystem offers are four partially overlapping approaches. Each one hits some of CabloyJS's capabilities; none covers all of them.

To see this clearly, we first need to break CabloyJS apart.

1. Split CabloyJS into five comparable capability layers

Calling something a "fullstack framework" makes comparison meaningless. CabloyJS's value actually lives on five independent layers:

1. Modularity and scaffolding — business capabilities are organized as modules that can be installed, composed, and removed, with a CLI that generates the standard structure.
2. Backend IoC/DI — services, controllers, and beans collaborate through dependency injection instead of layered imports and manual wiring.
3. Frontend-backend integration — one framework constrains both sides, so routing, permissions, validation, and error handling follow the same conventions.
4. RBAC and Workflow — the permission model and workflow engine are built into the framework, not "install a library and wire it up."
5. Metadata-driven design — data structures, forms, lists, and permission points are described by metadata, and both sides start from the same definition.

Now hold these five layers against the candidates.

2. Why Next.js itself is not the counterpart

Next.js defines itself as a React meta-framework. It solves rendering modes (SSR/CSR/RSC), routing, builds, deployment, and edge runtimes — extending the frontend all the way into the server.

Its Route Handlers and Server Actions are enough to write endpoints, but they do not provide enterprise backend architecture constraints: no dependency injection container, no module lifecycle, no built-in permission model, and no workflow engine. In Next.js, all of that belongs to the "choose your own stack and assemble it yourself" category.

So the question should not be "is there a CabloyJS replacement inside Next.js," but rather: within the React/Next.js ecosystem, which combination fills in those CabloyJS layers?

3. Path one: fullstack conventions — RedwoodJS and Blitz.js

If what appeals to you is "one framework owns both sides and tells you, with strong conventions, where business logic belongs," these two frameworks come closest.

RedwoodJS

RedwoodJS is one of the most opinionated fullstack frameworks in the React ecosystem. In its classic form, it puts the React frontend, GraphQL API, Prisma data layer, and directory conventions into a single monorepo.

• Scaffolding: generate commands produce pages, Cells, Services, and GraphQL SDL in one pass, turning "where should this capability live" into a fixed answer.
• Clear boundaries: the frontend handles presentation and interaction, data access is confined to the service layer, and server-side validation and tests have a defined home.
• One caveat: Redwood has spent the past couple of years evolving toward RedwoodSDK, with changes to both its technical foundation and deployment model. When choosing it, confirm which generation you are actually adopting rather than relying on older docs describing the GraphQL + Prisma setup.

Blitz.js

Blitz.js is built directly on top of Next.js, with the explicit goal of erasing the frontend-backend boundary.

• Zero-API data layer: the frontend can import backend queries and mutations directly; Blitz compiles them into RPC endpoints and client calls at build time. This removes the hand-written API glue layer and is where it most resembles CabloyJS's "one integrated stack."
• Built-in auth and sessions: authentication and session management work out of the box, with ready-made hooks for authorization checks.
• Boundary: it provides authentication and access-control infrastructure, not a full RBAC permission-point system or workflow engine. Organization-level permission models still need to be modeled by you.

Who it fits: teams that want to stay entirely inside the Next.js ecosystem while getting "write the backend, call it from the frontend, with login state included." For that need, Blitz.js is the first choice. If you are not tied to Next.js but want an opinionated fullstack framework in React, look at RedwoodJS.

4. Path two: admin panels and metadata-driven design — Refine

CabloyJS is often used to build complex enterprise admin systems quickly. If your core need is permissions, auto-generated CRUD, and direct access to a database or existing API, you do not need to replace Next.js — just bring in Refine.

Refine is an open-source meta-framework for React admin panels that runs seamlessly on Next.js, Remix, or Vite.

• Provider-based metadata thinking: dataProvider connects a data source (REST, GraphQL, Supabase, Prisma, etc.), authProvider handles login state, and accessControlProvider carries ACL/RBAC decisions. You define how to fetch and how to authorize; Refine wires up CRUD pages, forms, lists, and i18n.
• UI-agnostic: it does not bind to a component library, so you keep Next.js's navigation and rendering modes without being locked in.
• Boundary: Refine is a frontend-side meta-framework and does not provide a backend runtime. Authorization must ultimately be enforced by your API or database, and workflows are out of its scope entirely.

Who it fits: teams that already have a backend (or plan to use Supabase or their own API) and whose main pain is repeated admin-panel and permission work.

5. Path three: backend IoC — NestJS + Next.js

CabloyJS's backend offers Spring-like dependency injection. If your team values backend architectural rigor more than the convenience of a single all-in-one framework, the common answer is a combo plus a monorepo:

• Manage the repo with Nx or Turborepo;
• Let Next.js handle SSR, SEO, and the BFF layer;
• Let NestJS own the real enterprise business backend.

NestJS is the most mature IoC/DI backend framework in Node.js today: Module, Provider, Guard, Interceptor, and Pipe form a complete set of architectural constraints, with clear module boundaries and test isolation.

The cost: frontend and backend are no longer governed by one framework, so routing, permissions, DTO validation, and error codes must be explicitly aligned across two systems. In other words, the consistency CabloyJS gets from "one shared metadata contract" has to be recovered here through engineering conventions and shared packages.

Who it fits: large commercial projects that need to evolve for years and cannot compromise on backend architecture. This combination is not weaker than CabloyJS in rigor or modularity — but it is not "batteries included," it is "architecture included."

6. How the four options compare

Requirement	CabloyJS capability	React/Next.js option	Recommendation
Integration and automation	Modules, CLI generation, unified frontend/backend	Blitz.js / RedwoodJS	Choose these to skip auth and API glue work
Fast admin panels and permissions	Built-in RBAC, Workflow, auto CRUD	Refine (embeddable in Next.js)	Choose it when the core is admin, forms, and access control
Top-tier backend architecture (IoC)	Dependency injection and modularity via Egg/Vona	NestJS + Turborepo/Nx	Choose it for large, long-lived systems where backend rigor comes first
Workflow engine	Built-in Workflow	No direct counterpart; build or integrate one	Evaluate separately for process-heavy systems
Shared frontend/backend metadata	One metadata source drives both sides	Partial overlap (Refine providers, Redwood conventions)	No complete equivalent; fill the gap with conventions

7. Selection advice

• Staying fully inside Next.js, valuing "write the backend, use it in the frontend, login included": Blitz.js first.
• Not tied to Next.js but wanting an opinionated React fullstack framework: RedwoodJS first — but confirm its current form and deployment model.
• Mainly enterprise admin panels, forms, and permissions: Refine has the best return on effort, with no backend replacement required.
• Backend rigor first, system expected to live for many years: the NestJS + Next.js monorepo is the safer bet.

One honest closing note: all four options can reproduce most of the day-to-day CabloyJS experience, but none fully replicates its five-layer structure of modules + IoC + RBAC + Workflow + metadata. The React/Next.js ecosystem wins on freedom of choice and an enormous supply of components and training material; CabloyJS wins by building enterprise constraints in advance and reducing how much architectural freedom a team has to improvise.

These are not substitutes for each other. They are a trade-off between free composition and built-in conventions. Decide which cost you fear more, and the answer follows.