Skip to main content
Node Blueprint CLI currently supports Express as the primary web framework. Fastify support is planned for future releases.

​
Available Frameworks

Express

Full-featured web framework with extensive middleware ecosystem and robust logging

Fastify

Coming soon - High-performance framework with schema validation

​
Express Framework

Express is the default and currently supported framework. It provides a production-ready setup with:
  • Winston logger with daily log rotation
  • CORS and Helmet security middleware
  • Structured error handling
  • Cookie parser and JSON body parsing
  • EJS view engine support

​
Generated Files

When you select Express, the CLI generates: Core Application (src/app.ts): 
import path from "path";
import { fileURLToPath } from "url";
import cookieParser from "cookie-parser";
import express, { type Request, type Response } from "express";

import router from "./router.js";
import ErrorMiddleware from "./middlewares/error-middleware.js";
import { CorsMiddleware } from "./middlewares/cors-middleware.js";
import { HelmetMiddleware } from "./middlewares/helmet-middleware.js";

const __dirname = path.dirname(fileURLToPath(import.meta.url));

// create express app instance
const app = express();

// Security middleware
app.use(HelmetMiddleware);

// CORS middleware
app.use(CorsMiddleware);

// basic express configuration
app.set("view engine", "ejs");
app.set("views", path.join(__dirname, "views"));
app.use(express.static(path.join(__dirname, "./public")));

// other middleware
app.use(express.json());
app.use(cookieParser());
app.use(express.urlencoded({ extended: true }));

// routes
app.get("/", (req: Request, res: Response) => {
    res.json({ message: "Hello from Node Blueprint Starter" });
});
app.use(router);

// error middleware
app.use(ErrorMiddleware);

export default app;
Server Setup (src/server.ts): 
import app from "./app.js";
import dotenv from "dotenv";
import http from "node:http";
import path from "node:path";
import logger from "./config/logger.js";

// Load env variables
dotenv.config({ path: path.resolve(process.cwd(), ".env") });

// Create server
const PORT = process.env.PORT || 8000;
const server = http.createServer(app);

const startServer = async () => {
    server.listen(PORT, () => {
        console.log(`🚀 HTTP Server running on port ${PORT}`);
        logger.info(`🚀 HTTP Server running on port ${PORT}`);
    });
};

// Handle graceful shutdown
const shutdown = () => {
    server.close(() => {
        logger.info("Shutting down server...");
        process.exit(0);
    });
};

process.on("SIGTERM", shutdown);
process.on("SIGINT", shutdown);

startServer();
CORS Middleware (src/middlewares/cors-middleware.ts):
  • Configures cross-origin resource sharing
  • Customizable allowed origins
Helmet Middleware (src/middlewares/helmet-middleware.ts):
  • Sets security-related HTTP headers
  • Protects against common vulnerabilities
Error Middleware (src/middlewares/error-middleware.ts):
import logger from "../config/logger.js";
import type { NextFunction, Request, Response } from "express";

const ErrorMiddleware = (err: any, _req: Request, res: Response, next: NextFunction) => {
    err.status = err.status || 500;
    err.message = err.message || "Internal Server Error";

    logger.error(err.message);

    res.status(err.status).json({
        success: false,
        message: err.message
    });
}

export default ErrorMiddleware;

​
Winston Logger

Express projects include a production-ready Winston logger with:
  • Daily log rotation - Logs automatically rotate daily
  • Separate error logs - Error-level logs stored separately
  • Compressed archives - Old logs are zipped to save space
  • 180-day retention - Logs kept for 6 months
  • 50MB max file size - Automatic rotation on size limit
Logger Configuration (src/config/logger.ts): 
import * as winston from 'winston';
import { createLogger } from 'winston';
import DailyRotateFile from 'winston-daily-rotate-file';
const { combine, timestamp, json, errors, colorize } = winston.format;

const levels = { error: 0, warn: 1, info: 2, http: 3, debug: 4 };
const logLevel = process.env.NODE_ENV === 'production' ? 'error' : 'debug';

const errorLogsTransport = new winston.transports.DailyRotateFile({
    filename: '/tmp/winston-logs/error-%DATE%.log',
    datePattern: 'YYYY-MM-DD',
    zippedArchive: true,
    maxSize: '50m',
    maxFiles: '180d',
    level: 'error'
});

const allLogsTransport = new DailyRotateFile({
    filename: '/tmp/winston-logs/all-%DATE%.log',
    datePattern: 'YYYY-MM-DD',
    zippedArchive: true,
    maxSize: '50m',
    maxFiles: '180d'
});

const logger = createLogger({
    level: logLevel,
    levels,
    format: combine(
        timestamp(),
        json(),
        colorize(),
        errors({ stack: true }),
    ),
    transports: [
        new winston.transports.Console(),
        allLogsTransport,
        errorLogsTransport
    ]
});

export default logger;

​
Dependencies

Express projects include: 
{
  "dependencies": {
    "express": "^5.1.0",
    "cors": "^2.8.5",
    "helmet": "^8.1.0",
    "winston": "^3.17.0",
    "winston-daily-rotate-file": "^5.0.0",
    "cookie-parser": "^1.4.6"
  },
  "devDependencies": {
    "@types/express": "^5.0.3",
    "@types/cors": "^2.8.19"
  }
}

​
Directory Structure

Express projects follow this structure: 
src/
├── app.ts                 # Express app configuration
├── server.ts              # HTTP server setup
├── router.ts              # Main router
├── config/
│   ├── logger.ts          # Winston logger setup
│   └── cors.ts            # CORS configuration
├── middlewares/
│   ├── cors-middleware.ts
│   ├── helmet-middleware.ts
│   └── error-middleware.ts
├── routes/                # Route definitions
├── controllers/           # Request handlers
└── views/                 # EJS templates
The CLI automatically configures all middleware, logging, and security features so you can start building immediately.

Build docs developers (and LLMs) love

Get started for freeTalk to us