Everything fits together
See how routing, controllers, services, dependency injection, and middleware compose into one application model
import { router, bindHttp } from "./eridu/_module";
import { UserController } from "./2-controller";
router
.endpoint({
url: "/users/:id",
method: "GET",
handler: bindHttp(UserController, "get"),
})
.endpoint({
url: "/users/:id",
method: "DELETE",
handler: bindHttp(UserController, "delete"),
});
Why eridu-tech?
An embeddable, composable TypeScript framework designed for modern fullstack applications. Eridu gives you the backend primitives and application infrastructure you need while letting your existing frontend framework remain in control.
Embeddable by design
Use Eridu inside the framework you already know. Embed it into Next.js, TanStack Start, Nuxt, or other fullstack frameworks without taking over your application's routing, rendering, or deployment model.
Compose only what you need
Eridu is built from independent, composable capabilities. Add HTTP routing, dependency injection, cache, storage, events, queues, CLI, serialization, transactions, and more as your application needs them, without adopting an all-or-nothing framework runtime.
Own and customize your code
Inspired by the shadcn approach, Eridu is designed to let you build with code you control. Scaffold the capabilities you need into your application, customize them freely, and extend them without being locked into opaque framework internals.
Switch infrastructure without rewriting business logic
Adapters keep your application decoupled from infrastructure vendors. Use Redis today and switch to another implementation tomorrow without rewriting the business logic built on top of it.
Small runtime footprint
Because capabilities are independently composable, you don't need to carry an entire framework runtime when you only use a few parts of Eridu. Optional drivers and integrations are added only when your application actually needs them.
Batteries included
Eridu provides a broad set of production-ready capabilities and integrations so you don't have to assemble your backend infrastructure from unrelated libraries. Start with a cohesive foundation and add more as your application grows.
Who is this for?
eridu-tech is built primarily for fullstack and backend TypeScript developers who want a composable backend framework that can live inside the fullstack framework they already use.
Perfect for
- Fullstack TypeScript applications: Build complete applications with a frontend and backend in the same project, while using Eridu for DI, HTTP, cache, storage, events, queues, CLI, transactions, serialization, and other backend capabilities.
- Developers who want framework flexibility: Use Eridu without being locked into a specific frontend or fullstack framework. Its boundaries are designed to integrate with different routers, runtimes, and execution environments.
- Composable architectures: Add only the capabilities your application needs and combine them into a single coherent foundation instead of adopting an all-or-nothing backend stack.
- Framework-style development without framework lock-in: Get conventions for controllers, DI, routing, middleware, validation, events, queues, scheduling, and infrastructure adapters while keeping ownership of your application code and composition.
- Shadcn-style ownership: Scaffold capabilities into your project, customize them to fit your application, and extend the generated code instead of depending on opaque framework internals.
- Modular monoliths: Build multiple application domains and vertical slices on top of a shared DI container and infrastructure foundation while keeping modules independently composable.
Not ideal for
- Frontend-only applications: eridu-tech is focused on server-side and fullstack applications rather than browser-only applications.
- Microservices as the primary architecture: Eridu is particularly well suited to modular monoliths and cohesive applications where infrastructure and domain modules can share a runtime and common abstractions. Individual Eridu capabilities can still be used in distributed systems and services.
- Projects tightly coupled to one vendor: If your application intentionally depends on provider-specific APIs and features, Eridu's abstraction and adapter model may provide little benefit.
- Applications requiring provider-specific capabilities: Generic abstractions may not expose every feature of a particular database, cloud platform, or infrastructure provider. In those cases, using the provider's native SDK directly may be more appropriate.
- Very small scripts: If you only need a single Redis call, file upload, or cache operation, introducing a framework-level abstraction may be unnecessary.
- Pure JavaScript projects prioritizing minimal abstraction: eridu-tech is designed primarily for TypeScript and makes extensive use of its type system, generics, and inference for the best developer experience.
Officially Maintained Components
A growing collection of officially maintained components. Every component ships with multiple built-in adapters: swap infrastructure without changing a single line of business logic.
🔮 Upcoming Components
Components currently in design or development, not yet available in any release.
A unified API for defining and executing CLI commands with a transport adapter architecture. Run commands locally via child processes, remotely over SSH or HTTP, inside Docker containers, or through custom transports, all from the same command definition.
Run async tasks in structured scopes where child tasks are tied to their parent's lifetime, with automatic cancellation, error propagation, and resource cleanup.
A configurable promise queue to control the number of concurrently executing promises and prevent resource exhaustion.
Support for observability, logging, metrics, and tracing, with a pluggable adapter system. Pre-built adapters for OpenTelemetry and a local adapter that saves logs, traces, and metrics to disk.
Inspect the actual runtime state of any component through pre-built CLI commands, view registered handlers, active jobs, queue depth, lock holders, and more without digging into logs or metrics.
Schedule work with full flexibility, immediate dispatch, delayed execution, and recurring jobs. Uses Transaction Context for reliable execution.
How eridu-tech compares
An application-owning backend framework vs an embeddable, composable framework.
- Built around a Nest application and module graph with controllers, providers, and dependency injection.
- Decorators and framework modules are central to the application model.
- The primary composition model is a Nest application, with Nest owning the backend runtime and application lifecycle.
- Application code follows Nest's module and framework conventions.
- Infrastructure is commonly integrated through Nest-specific modules and providers.
- Designed for backend applications including monoliths and microservices.
- Framework abstractions remain part of the application architecture.
- Embeddable backend framework that can live inside Next.js, TanStack Start, Nuxt, and other fullstack frameworks.
- Plain TypeScript classes and explicit composition, no decorators required.
- Eridu provides the backend framework layer while the host framework can remain responsible for the frontend, and deployment.
- Compose routers, controllers, services, DI, middleware, and infrastructure explicitly.
- Own adapter-based primitives for cache, storage, locks, events, queues, and more.
- Designed primarily for composable applications and modular monoliths.
- Scaffold capabilities into your application and own the resulting source code, inspired by the shadcn approach.
Ready to build something great?
Get up and running in minutes with a single install.
npm install eridu-tech