From Express

Most of what you know from Express transfers directly — routes, middleware, and error handling all exist in NextRush. The biggest change is that req and res merge into a single ctx object, and middleware runs as an onion (before-and-after in one function) instead of a linear chain.

Concept Mapping

Before / After

import express from 'express';

const app = express();
app.use(express.json());

app.get('/users/:id', (req, res) => {
  const user = findUser(req.params.id);
  if (!user) {
    return res.status(404).json({ error: 'Not found' });
  }
  res.json(user);
});

app.listen(8080);

import { createApp, createRouter, listen } from 'nextrush';
import { bodyParser } from '@nextrush/body-parser';
import { NotFoundError } from 'nextrush';

const app = createApp();
app.use(bodyParser());

const users = createRouter();
users.get('/:id', (ctx) => {
  const user = findUser(ctx.params.id);
  if (!user) throw new NotFoundError('Not found');
  ctx.json(user);
});
app.route('/users', users);

listen(app, 8080);

createApp, createRouter, and listen all come from the nextrush meta package — see the Quick Start if you haven't installed it yet. bodyParser is a separate install (@nextrush/body-parser), same as Express's body-parser used to be before express.json() was folded in.

Middleware: linear chain vs. onion

Express middleware runs once, forward. NextRush middleware wraps the rest of the chain, so "before" and "after" logic live in the same function:

// Express — needs a 'finish' event to run code after the response
app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    console.log(`${req.method} ${req.url} ${Date.now() - start}ms`);
  });
  next();
});

// NextRush — before and after in one function
app.use(async (ctx, next) => {
  const start = Date.now();
  await next();
  console.log(`${ctx.method} ${ctx.path} ${Date.now() - start}ms`);
});

NextRush's Middleware type accepts both the modern async (ctx) => { await ctx.next(); } form and this traditional async (ctx, next) => { await next(); } form — pick whichever reads more naturally for a given handler.

Error handling

Express error middleware must be last-registered and take exactly four parameters. NextRush throws typed error classes and reads the status code off the error itself:

import { NotFoundError, BadRequestError } from 'nextrush';

router.get('/users/:id', (ctx) => {
  const user = findUser(ctx.params.id);
  if (!user) throw new NotFoundError('User not found');
  ctx.json(user);
});

// Optional: a custom handler for anything not already an HttpError
app.setErrorHandler((error, ctx) => {
  ctx.status = 500;
  ctx.json({ error: 'Internal error' });
});

NotFoundError, BadRequestError, and the rest of the HTTP error hierarchy come from @nextrush/errors and are re-exported by nextrush — see the error handling reference for the full list.

Common middleware translation

Next steps

• Middleware — the onion model, in depth.
• Context — everything ctx carries.
• Routing — routers, mounting, and route parameters.