AxilJS is a complete JavaScript backend ecosystem — HTTP, ORM, auth, AI, queues, observability, and cloud in one coherent platform. No assembling 40 packages from 40 different teams.
➜ ~ npx @axiljs/cli create my-api
Scaffolding AxilJS project...
✓ Project structure
✓ TypeScript config (strict mode)
✓ All 17 packages installed
✓ .env.example generated
➜ ~/my-api npm run dev
⚡ AxilJS v0.2.2 — development server
────────────────────────────────────
✓ Server http://localhost:3000
✓ Auth JWT · RBAC · scrypt
✓ Security helmet · rate-limit · CSRF
✓ ORM PostgreSQL · MySQL · SQLite
✓ AI OpenAI · Anthropic · Gemini · Ollama
✓ Memory leak detection active · GC optimized
✓ Queue workers online · scheduler running
Watching src/ for changes... (incremental compilation)
➜ ~/my-api
Platform Overview
Each layer is independently useful but designed to compose into a complete production system — without glue code, without configuration fatigue, without dependency hell.
# One command
$ axil create my-api
$ cd my-api
$ axil run
⚡ Ready. Zero config.
Trie-based HTTP router with O(log n) matching. Async middleware chain. Body parsing, static files, and Server-Sent Events streaming. Built-in SyntaxilitY Response Manager for consistent JSON responses across every endpoint.
Production security headers via Helmet. Per-IP rate limiting with configurable windows (5 req/15 min on auth routes). CSRF protection. Input sanitization against XSS. Applied globally with one line.
ORM with PostgreSQL (NeonDB/SSL), MySQL, and SQLite drivers. Fluent query builder. Automatic migrations with SERIAL/AUTOINCREMENT per driver. JWT with HMAC-SHA256. Password hashing via scrypt. Full RBAC middleware.
Event bus with wildcard support. RFC 6455 WebSocket server with rooms and broadcast. Message queue with exponential backoff and cron scheduler. Circuit breaker with fallback. Prometheus metrics. W3C distributed tracing.
Provider-agnostic LLM abstraction for OpenAI, Anthropic, Gemini, and Ollama (local, no API key). RAG pipeline with vector store and document indexing. AI agents with tool calling and max iteration control. MCP client.
Multi-tenant isolation middleware. Immutable audit logging. Feature flags with percentage rollout. Docker Dockerfile generation. Kubernetes deployment + HPA manifests. Memory leak detection with auto-fix and GC optimization.
Developer Experience
Every import in this example comes from the same ecosystem. No third-party auth library. No separate validation package. No external security middleware. Full TypeScript inference from request to response.
CLI
1import { Application, cors } from '@axiljs/core'
2import { loadEnv, defineConfig } from '@axiljs/config'
3import { helmet, rateLimit } from '@axiljs/security'
4import { JWT, authenticate, requireRole } from '@axiljs/auth'
5import { v, validate } from '@axiljs/validation'
6
7// Typed env validation — fails fast on startup
8loadEnv()
9const config = defineConfig({
10 PORT: { type: 'number', default: 3000 },
11 JWT_SECRET: { type: 'string', required: true }
12})
13
14// One application, zero configuration
15const app = new Application({ server: { port: config.PORT } })
16const jwt = new JWT(config.JWT_SECRET)
17
18// Security applied globally in three lines
19app.use(helmet())
20app.use(cors())
21app.use(rateLimit({ max: 100, windowMs: 60000 }))
22
23// Auth + validation composed per route
24app.post('/users',
25 authenticate(jwt),
26 requireRole('admin'),
27 validate({ body: v.object({
28 name: v.string().min(2).max(100),
29 email: v.string().email(),
30 role: v.enum(['admin', 'user']),
31 }) }),
32 async (req, res) =>
33 res.created(req.body, 'User created')
34)
35
36app.listen()Built-in Response Manager
The SyntaxilitY API Response Manager is built directly into the res object. No imports needed. Every response is automatically formatted with status codes, typed messages, and pagination metadata.
res.success(data, msg)→200 OKres.created(data, msg)→201 Createdres.paginated(...)→200 + paginationres.notFound(msg)→404 Not Foundres.unauthorized(msg)→401 Unauthorizedres.forbidden(msg)→403 Forbiddenres.validationError(msg)→422 Unprocessableres.tooManyRequests()→429 Rate Limited{
"status": 200,
"code": "HTTP_200_OK",
"message": "Users fetched",
"data": {
"metadata": [ ... ],
"pagination": {
"total": 42,
"page": 1,
"limit": 10,
"totalPages": 5,
"hasNextPage": true,
"hasPrevPage": false
}
}
}{
"status": 422,
"code": "HTTP_422_UNPROCESSABLE_ENTITY",
"message": "Validation failed",
"errors": {
"email": "Must be a valid email",
"name": "Minimum 2 characters"
}
}All Packages
All under @axiljs — designed to compose, independently useful, no circular dependencies.
@axiljs/coreHTTP server, router, middleware, SSE, static files, response management
@axiljs/commonShared utilities, types, HTTP abstractions, errors, and framework primitives
@axiljs/configEnvironment loading, typed configuration, validation, and configuration management
@axiljs/securityHelmet headers, rate limiting, CSRF protection, and input sanitization
@axiljs/ormType-safe ORM with PostgreSQL, MySQL, SQLite, queries, entities, and migrations
@axiljs/authJWT authentication, password hashing with scrypt, authorization, and RBAC
@axiljs/validationSchema-based request validation with typed schemas and structured validation errors
@axiljs/testingTest runner, assertions, HTTP testing client, and application testing utilities
@axiljs/eventsIn-process event bus with pub/sub, wildcard events, and event-driven architecture
@axiljs/websocketRFC 6455 WebSocket server with connections, rooms, broadcasting, and events
@axiljs/queueBackground jobs, message queues, cron scheduling, retries, and job processing
@axiljs/circuitCircuit breaker, retry policies, timeouts, fallbacks, and fault tolerance
@axiljs/observabilityStructured logging, Prometheus metrics, distributed tracing, and health checks
@axiljs/aiLLM abstraction, RAG pipelines, AI agents, embeddings, vector stores, and MCP
@axiljs/cloudMulti-tenancy, audit logs, feature flags, Docker, Kubernetes, and deployment tools
@axiljs/memoryHeap monitoring, memory leak detection, garbage collection analysis, and optimization
@axiljs/cliDeveloper CLI for project creation, development, building, testing, and deployment
@axiljs/pmAxilJS package manager for dependency management, workspace operations, and packages
Ecosystem Comparison
Built-in capabilities across modern Node.js frameworks
| Capability | Express | Fastify | NestJS | Hono | AxilJS |
|---|---|---|---|---|---|
| HTTP Server & Router | |||||
| Middleware Pipeline | |||||
| SSE Streaming | — | ||||
| Static File Serving | |||||
| Built-in Response Manager | — | — | — | — | |
| ORM & Database Layer | — | — | — | — | |
| Database Migrations | — | — | — | — | |
| JWT Authentication | — | — | — | ||
| RBAC Authorization | — | — | — | ||
| Schema Validation | — | — | — | ||
| Security Middleware | — | ||||
| Rate Limiting | — | — | |||
| CSRF Protection | — | — | — | ||
| Input Sanitization | — | — | — | — | |
| Testing Toolkit | — | — | — | ||
| HTTP Test Client | — | — | — | — | |
| Event Bus | — | — | — | — | |
| WebSockets | — | ||||
| Background Jobs & Queue | — | — | — | ||
| Scheduler / Cron | — | — | — | ||
| Circuit Breaker | — | — | — | — | |
| Structured Logging | — | — | — | ||
| Prometheus Metrics | — | — | — | — | |
| Distributed Tracing | — | — | — | — | |
| Health Checks | — | — | — | ||
| AI / LLM Platform | — | — | — | — | |
| RAG Pipeline | — | — | — | — | |
| AI Agents | — | — | — | — | |
| MCP Support | — | — | — | — | |
| Multi-Tenancy | — | — | — | — | |
| Audit Logs | — | — | — | — | |
| Feature Flags | — | — | — | — | |
| Memory Monitoring | — | — | — | — | |
| Memory Leak Detection | — | — | — | — | |
| GC / Heap Optimization | — | — | — | — | |
| Docker / Kubernetes Support | — | — | — | ||
| CLI Tooling | |||||
| Zero-Config Start | |||||
| Modular Architecture | — | ||||
| Enterprise Architecture | — | — | — |
Partial support counts as ✗. AxilJS ships every capability as a first-party package with consistent APIs.
Architecture Support
AxilJS is designed as a complete backend ecosystem rather than a single-purpose HTTP framework. Build monoliths, modular systems, distributed services, event-driven platforms, and AI-native applications using the same ecosystem.
A structured Model-View-Controller architecture for applications that benefit from explicit separation of responsibilities.
npx axil create blog --architecture mvcArchitecture
A complete application deployed as a single unit while retaining access to the full AxilJS ecosystem.
npx axil create shop --architecture monolithArchitecture
Organize a large application into isolated business modules without introducing distributed-system complexity.
npx axil create platform --architecture modularArchitecture
Decompose applications into independently deployable services with communication, resilience, and observability built into the ecosystem.
npx axil create platform --architecture microserviceArchitecture
Build asynchronous and reactive systems using the AxilJS event bus, queues, schedulers, retries, and background workers.
npx axil create worker --architecture event-drivenArchitecture
Build AI-powered backend systems with LLM providers, RAG pipelines, agents, embeddings, vector stores, and MCP.
npx axil create ai-app --architecture aiArchitecture
Same ecosystem. Different architecture.
Core, Security, ORM, Auth, Validation, Testing, Events, Queue, Observability, AI, Cloud, and Memory modules work across your application architecture.
Roadmap
AxilJS is being developed as a complete backend ecosystem. Core runtime capabilities, security, ORM, authentication, testing, real-time systems, observability, AI, cloud, memory, and developer tooling are already part of the platform.
HTTP server, routing, middleware, SSE streaming, static files, and the built-in response manager.
Environment loading, typed configuration, validation, defaults, and fail-fast startup configuration.
Helmet headers, rate limiting, CSRF protection, sanitization, and security middleware.
Type-safe ORM, entities, repositories, query building, transactions, and database migrations.
JWT authentication, password hashing, RBAC authorization, schema validation, and typed validation errors.
Test runner, assertions, HTTP test client, and application-level testing utilities.
Event bus, pub/sub, WebSocket support, rooms, broadcasting, and event-driven communication.
Queues, background jobs, schedulers, retries, timeouts, and resilient job processing.
Circuit breakers, structured logging, metrics, tracing, health checks, and production diagnostics.
LLM providers, streaming, embeddings, RAG pipelines, AI agents, vector stores, and MCP.
Multi-tenancy, audit logs, feature flags, containerized deployment, and Kubernetes-oriented infrastructure.
Heap monitoring, memory leak detection, garbage collection analysis, and runtime optimization.
Project scaffolding, development workflow, builds, testing, package management, and deployment commands.
Advanced microservice patterns, service communication, distributed events, resilience, and service-level observability.
AxilJS brings HTTP, ORM, authentication, validation, security, real-time communication, queues, observability, AI, cloud, memory management, and developer tooling into one modular TypeScript ecosystem.
$ npm install @axiljs/core
+ @axiljs/core
+ AxilJS ecosystem ready
$ npx axil create my-api
$ cd my-api
$ npm run dev
⚡AxilJS readyatlocalhost:3000