🌐 railizator

LIVE EXAMPLE

🚀 Lightweight decorator-based routing & pipeline layer built on railiz.

railizator provides decorators, typed params, and pipelines to organize domain logic over railiz.

Why Railizator?

Building scalable Node backends usually means trade-offs:

• Express → flexible but untyped
• Fastify → fast but opinionated
• NestJS → structured but heavy

👉 Railizator gives you structured decorators + pipeline orchestration while leveraging Railiz core engine.

Advantages

• ⚡ Decorator-based routing (@Controller, @Get, @Post, etc.)
• 🧩 Pipeline orchestration (@Pipeline)
• 🧠 Deterministic middleware execution (no order bugs)
• 🔌 Plugin-first architecture
• 🪶 Ultra-lightweight
• 📝 Full TypeScript inference (params, context)
• 🌐 Framework-agnostic (works anywhere Railiz works)

Installation

npm install railiz railizator

Quick Example (Direct Railiz instance)

import { PipelineBuilder, Railiz, queryParser, json } from 'railiz'
import { type BaseContext } from 'railiz'
import {
  Controller,
  Get,
  Post,
  Catch,
  Use,
  Pipeline,
  Body,
  Query,
  Param,
  addControllers,
} from 'railizator'

const app = new Railiz()

// Global middleware
app.use(json()).use(queryParser())

// Middleware
const log = async (ctx: BaseContext, next?: () => Promise<void>) => {
  console.log(`[LOG] ${ctx.method.toUpperCase()} ${ctx.path}`)
  await next?.()
}

@Use(log)
@Controller('/users')
class UserController {
  @Get('/:id')
  async getUser(@Param('id') id: string, @Query() query: any, ctx: BaseContext) {
    ctx.json({ id, query })
  }

  @Post('/')
  @Pipeline((p: PipelineBuilder<BaseContext>) => {
    p.use(async (ctx, next) => {
      if (!ctx.data.body?.name) return ctx.text('Missing name', 400)
      await next?.()
    })
  })
  async createUser(@Body() body: any, ctx: BaseContext) {
    ctx.json({ created: true, body })
  }
}

// Register controllers
addControllers(app, [UserController])

app.createServer().listen(3001, () => console.log('http://localhost:3001'))

Factory Example

import { createApp } from 'railiz'
import { Controller, Get, addControllers } from 'railizator'

const { app } = createApp()

@Controller('/ping')
class PingController {
  @Get('/')
  ping(ctx: any) {
    ctx.text('pong')
  }
}

// Register
addControllers(app, [PingController])

app.run(3002) // http://localhost:3002

Railizator fully supports both new Railiz() and createApp() style.

Core

• Routing: Radix-tree or linear routes
• Typed Params: @Body(), @Query(), @Param('id')
• Middleware: @Use() for route/controller/global
• Pipeline: @Pipeline(fn) for deterministic ordering
• Plugins: Extend app features easily

Philosophy

You control:
- Architecture
- Domain logic
- Decorators & pipelines

Railizator controls:
- Typed param extraction
- Deterministic middleware execution
- Controller registration over Railiz

Recommended

Railizator works on top of railiz, so make sure to check railiz for core server engine, context, and low-level middleware.

License

MIT