Middleware Overview

bunWay ships with a complete set of Express-compatible middleware—no npm hunting required. Same APIs you know, just faster.

Built-in Middleware

bunWay	Express Equivalent	Description
json()	express.json()	Parse JSON request bodies
urlencoded()	express.urlencoded()	Parse URL-encoded form data
text()	express.text()	Parse plain text bodies
cors()	cors	Handle CORS headers and preflight
helmet()	helmet	Set security headers
session()	express-session	Session management with stores
passport()	passport	Authentication strategies
logger()	morgan	Request logging with formats
csrf()	csurf	CSRF protection
rateLimit()	express-rate-limit	Rate limiting
serveStatic()	express.static()	Serve static files
cookieParser()	cookie-parser	Parse and sign cookies
compression()	compression	Gzip/deflate responses
upload()	multer	File uploads (multipart/form-data)
errorHandler()	Custom	Catch-all error handling

Quick Reference

Body Parsing

import { json, urlencoded, text } from 'bunway';

app.use(json({ limit: '10mb' }));
app.use(urlencoded({ extended: true }));
app.use(text());

Full documentation →

Security

import { helmet, csrf, rateLimit } from 'bunway';

app.use(helmet());
app.use(csrf({ cookie: { secure: true } }));
app.use(rateLimit({ windowMs: 60000, max: 100 }));

Full documentation →

Sessions

import { session } from 'bunway';

app.use(session({
  secret: 'my-secret',
  cookie: { maxAge: 86400000 }
}));

app.get('/profile', (req, res) => {
  req.session.views = (req.session.views || 0) + 1;
  res.json({ views: req.session.views });
});

Full documentation →

Authentication

import { passport, session } from 'bunway';

app.use(session({ secret: 'my-secret' }));
app.use(passport.initialize());
app.use(passport.session());

passport.use({
  name: 'local',
  authenticate(req) {
    const user = findUser(req.body.email, req.body.password);
    if (user) this.success(user);
    else this.fail('Invalid credentials');
  }
});

app.post('/login', passport.authenticate('local', {
  successRedirect: '/dashboard',
  failureRedirect: '/login'
}));

Full documentation →

Logging

import { logger } from 'bunway';

app.use(logger('dev'));                    // Colored dev output
app.use(logger('combined'));               // Apache combined format
app.use(logger(':method :url :status'));   // Custom format

Full documentation →

Static Files

import { serveStatic } from 'bunway';

app.use(serveStatic('public'));
app.use('/assets', serveStatic('assets', {
  maxAge: 86400000,
  etag: true
}));

Full documentation →

Cookies

import { cookieParser } from 'bunway';

app.use(cookieParser({ secret: 'my-secret' }));

app.get('/preferences', (req, res) => {
  console.log(req.cookies);        // Unsigned cookies
  console.log(req.signedCookies);  // Signed cookies
  res.cookie('theme', 'dark', { maxAge: 86400 });
  res.json({ ok: true });
});

Full documentation →

File Uploads

import { upload, diskStorage } from 'bunway';

app.post('/avatar', upload.single('avatar'), (req, res) => {
  res.json({ file: req.file.originalname });
});

app.post('/photos', upload.array('photos', 5), (req, res) => {
  res.json({ count: req.files.length });
});

Full documentation →

CORS

import { cors } from 'bunway';

app.use(cors());
app.use(cors({ origin: 'https://example.com' }));
app.use(cors({ origin: true, credentials: true }));

Full documentation →

Error Handling

import { errorHandler, HttpError } from 'bunway';

app.use(errorHandler());

app.get('/fail', (req, res) => {
  throw new HttpError(404, 'Not found');
});

Full documentation →

Creating Custom Middleware

bunWay middleware follows the Express (req, res, next) signature:

import type { Handler } from 'bunway';

const myMiddleware: Handler = (req, res, next) => {
  console.log(`${req.method} ${req.path}`);
  next();
};

app.use(myMiddleware);

Async Middleware

const asyncMiddleware: Handler = async (req, res, next) => {
  const user = await db.getUser(req.session.userId);
  req.user = user;
  next();
};

Error Handling Middleware

const errorMiddleware = (err: Error, req: Request, res: Response, next: NextFunction) => {
  console.error(err);
  res.status(500).json({ error: err.message });
};

app.use(errorMiddleware);