wpress-x

const WpressX = require('wpress-x')
const app = WpressX()

app.get('/hello/:name', (req, res) => {
  res.json({ hello: req.params.name })
})

app.done(3000)

npx wpress-x create my-app
cd my-app
npm start

const WpressX = require('wpress-x')
const app = WpressX()

// middleware: logging + body parsing + static files
app.use(WpressX.logger('dev'))
app.use(WpressX.json())
app.use(WpressX.urlencoded({ extended: true }))
app.use(WpressX.static('public'))

// routes
app.get('/', (req, res) => res.send('<h1>Hello wpress-x</h1>'))

app.get('/users/:id', (req, res) => {
  res.json({ id: req.params.id, q: req.query })
})

app.post('/login', (req, res) => {
  res.status(201).json({ user: req.body.name })
})

// start: app.done(), app.listen() and app.start() are the same call
app.done(3000, () => console.log('listening on http://localhost:3000'))

node app.js

curl http://localhost:3000/users/42?tab=posts
# {"id":"42","q":{"tab":"posts"}}

curl -X POST http://localhost:3000/login \
     -H 'content-type: application/json' \
     -d '{"name":"ali"}'
# {"user":"ali"}

'use strict'
const WpressX = require('wpress-x')
const app = WpressX()

/* ---------- middleware ---------- */
app.use(WpressX.helmet())
app.use(WpressX.cors({ origin: true, credentials: true }))
app.use(WpressX.compress())
app.use(WpressX.logger('dev'))
app.use(WpressX.json({ limit: '1mb' }))
app.use(WpressX.rateLimit({ windowMs: 60_000, max: 100 }))

/* ---------- in-memory data ---------- */
let nextId = 3
const todos = [
  { id: 1, title: 'Read the wpress-x docs', done: true },
  { id: 2, title: 'Ship something', done: false }
]

/* ---------- routes ---------- */
app.get('/api/todos', (req, res) => {
  res.json({ data: todos, count: todos.length })
})

app.get('/api/todos/:id', (req, res, next) => {
  const todo = todos.find((t) => t.id === Number(req.params.id))
  if (!todo) return next(WpressX.createError(404, 'No such todo'))
  res.json(todo)
})

app.post('/api/todos', (req, res) => {
  const todo = { id: nextId++, title: req.body.title, done: false }
  todos.push(todo)
  res.status(201).json(todo)
})

app.patch('/api/todos/:id', (req, res, next) => {
  const todo = todos.find((t) => t.id === Number(req.params.id))
  if (!todo) return next(WpressX.createError(404, 'No such todo'))
  Object.assign(todo, req.body)
  res.json(todo)
})

app.delete('/api/todos/:id', (req, res) => {
  const i = todos.findIndex((t) => t.id === Number(req.params.id))
  if (i === -1) return res.sendStatus(404)
  todos.splice(i, 1)
  res.sendStatus(204)
})

/* ---------- errors (always last) ---------- */
app.use((err, req, res, next) => {
  res.status(err.status || 500).json({ error: err.message })
})

app.done(3000, () => console.log(app.summary()))

GET     /api/todos
GET     /api/todos/:id
POST    /api/todos
PATCH   /api/todos/:id
DELETE  /api/todos/:id

app.get('/users/:id', (req, res) => res.json({ id: req.params.id }))
app.get('/num/:n(\\d+)', (req, res) => res.send(req.params.n))   // digits only
app.get('/opt/:id?', (req, res) => res.json({ id: req.params.id }))
app.get('/files/:path*', (req, res) => res.send(req.params.path))
app.get('/all/*', (req, res) => res.send('wildcard'))
app.get(/^\/regex\/(\d+)$/, (req, res) => res.send(req.params[0]))
app.get(['/a', '/b'], (req, res) => res.send('a or b'))

app.route('/article/:id')
  .get((req, res) => res.json({ id: req.params.id }))
  .put((req, res) => res.send('updated'))
  .delete((req, res) => res.send('deleted'))

// a standalone router, mounted anywhere
const api = WpressX.Router()
api.use((req, res, next) => { res.setHeader('X-Api', 'wpress-x'); next() })
api.get('/users', (req, res) => res.json(users))
app.use('/api', api)

// a prefixed group (a router is created for you)
app.group('/v1', (router) => {
  router.get('/ping', (req, res) => res.json({ pong: Date.now() }))
})

// a whole sub-application
const admin = WpressX()
admin.get('/', (req, res) => res.send('admin'))
app.use('/admin', admin)

// router options
const strict = WpressX.Router({ caseSensitive: true, strict: true, mergeParams: true })

app.param('id', (req, res, next, value) => {
  req.user = findUser(value)
  if (!req.user) return next(WpressX.createError(404, 'No such user'))
  next()
})

app.get('/users/:id', (req, res) => res.json(req.user))

app.use((req, res, next) => { console.log(req.method, req.path); next() })
app.use('/admin', requireAuth)                  // path-scoped
app.use('/api', apiRouter)                      // mount a Router
app.use('/blog', blogApp)                       // mount a sub-App
app.use(WpressX.json(), WpressX.urlencoded())   // several at once
app.us(middleware)                              // original spelling of use()

app.use((err, req, res, next) => {
  console.error(err)
  res.status(err.status || 500).json({ error: err.message })
})

// or the built-in handler, which shows stacks outside production
app.use(WpressX.errorHandler({ showStack: process.env.NODE_ENV !== 'production' }))

req.get('user-agent')                // header lookup, case-insensitive
req.accepts(['json', 'html'])        // 'json' | 'html' | false
req.acceptsLanguages(['en', 'ur'])   // 'en' | 'ur' | false
req.acceptsCharsets(['utf-8'])
req.acceptsEncodings(['gzip'])
req.is('json')                       // 'json' | false | null
req.param('id', 'default')           // params, then body, then query
req.range(size)                      // parsed Range header
req.cookie('name')                   // signed first, plain second
req.csrfToken()                      // with WpressX.csrf()

res.send('text')            // text/html
res.send({ a: 1 })          // application/json
res.send(Buffer)            // application/octet-stream
res.send(404)               // treated as a status code

res.json(obj)      res.jsonp(obj)      res.text(str)      res.html(str)
res.status(201).json(obj)
res.sendStatus(404)                    // 404 + "Not Found"

res.type('json')   res.set('X-A', '1')   res.get('X-A')   res.append('Link', v)
res.vary('Accept') res.links({ next: '/page/2' })
res.redirect('/done')                  // 302
res.redirect(301, 'https://example.com')

res.cookie('n', 1, { signed: true, httpOnly: true, maxAge: 3600000 })
res.clearCookie('n')
res.attachment('report.pdf')

res.format({
  'text/html':       () => res.send('<p>hi</p>'),
  'application/json': () => res.json({ hi: true }),
  default:           () => res.sendStatus(406)
})

res.render('index', { title: 'Hi' })
res.sse(data, 'event', id)             // Server-Sent Events
res.sseEnd()
res.stream(readableStream)             // pipe with automatic cleanup

app.locals.siteName = 'wpress-x'        // available everywhere

app.use((req, res, next) => { res.locals.user = req.user; next() })
// templates can now read both `siteName` and `user`

app.get('/cv', (req, res) => {
  res.sendFile('cv.pdf',
    { root: __dirname + '/files', maxAge: '1d' },
    (err) => { if (err) res.status(err.status || 500).send('no file') }
  )
})

// force a download with a custom filename
app.get('/dl', (req, res) => res.download('/tmp/report.pdf', 'report.pdf'))

// serve a whole directory, with caching and extension fallbacks
app.use(WpressX.static(__dirname + '/public', { maxAge: '1h', extensions: ['html'] }))

// and let people browse it
app.use('/files', WpressX.serveIndex(__dirname + '/public'))

// keep uploads in memory (req.files.field.buffer)
app.use(WpressX.multipart({ multiple: true }))

// or write them straight to disk
app.use(WpressX.upload({ dest: 'uploads', limits: { fileSize: 5 * 1024 * 1024 } }))

app.post('/avatar', (req, res) => {
  const file = req.files.avatar
  res.json({ name: file.originalname, size: file.size, path: file.path })
})

app.set('views', __dirname + '/views')
app.set('view engine', 'ejs')                  // the default for res.render

app.get('/',      (req, res) => res.render('index', { title: 'Hello' }))
app.get('/about', (req, res) => res.render('about.md'))      // any extension
app.get('/p',     (req, res) => res.render('page.pug'))
app.get('/h',     (req, res) => res.render('page.hbs'))

<h1><%= title %></h1>               <!-- escaped -->
<%- include('partials/nav', { title }) %>
<%# a comment %>
<%% a literal <% tag %>
<% items.forEach(function (item) { -%>
  <li><%= item.name %></li>
<% }) %>

extends layout

block content
  h1.heading#top= title
  ul
    each item, i in items
      li= i + ': ' + item
  mixin badge(label)
    span.badge= label
  +badge('new')
    p inside the mixin's block

<h1>{{title}}</h1>
{{{rawHtml}}}   {{&alsoRaw}}
{{#each items}}<li>{{@index}}: {{this.name}}</li>{{else}}<li>none</li>{{/each}}
{{#if ok}}yes{{else}}no{{/if}}
{{#with user}}{{name}} of {{../org}}{{/with}}
{{upper title}}   {{join names ", "}}
{{> footer}}

# About

Built with **wpress-x** — zero dependencies.

| Engine | Extension |
| ------ | --------- |
| EJS    | .ejs      |
| Pug    | .pug      |

app.engine('njk', (filePath, options, callback) => {
  callback(null, myRenderer(filePath, options))
})

// any Express-compatible engine drops straight in
app.engine('ejs', require('ejs').renderFile)

app.use(WpressX.cookieParser(process.env.SECRET))

app.use(WpressX.session({
  secret: process.env.SECRET,
  name: 'wpress-x.sid',
  resave: false,
  saveUninitialized: false,
  cookie: { maxAge: 3600000, httpOnly: true, sameSite: 'lax' }
}))

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

app.post('/logout', (req, res) => req.session.destroy(() => res.redirect('/')))

app.use(WpressX.cookieParser('secret'))
app.use(WpressX.session({ secret: 'secret', resave: false, saveUninitialized: false }))
app.use(WpressX.csrf())          // needs a session (or cookie) to store the secret

app.get('/form', (req, res) => {
  res.send(`<form method="post" action="/submit">
    <input type="hidden" name="_csrf" value="${req.csrfToken()}">
    <button>Send</button>
  </form>`)
})

app.use(WpressX.logger('dev'))
app.use(WpressX.helmet())
app.use(WpressX.cors({ origin: true, credentials: true }))
app.use(WpressX.compress({ threshold: 512 }))
app.use(WpressX.json({ limit: '1mb' }))
app.use(WpressX.urlencoded({ extended: true }))
app.use(WpressX.cookieParser(process.env.SECRET))
app.use(WpressX.session({ secret: process.env.SECRET, resave: false, saveUninitialized: false }))
app.use(WpressX.static('public'))
app.use(WpressX.rateLimit({ windowMs: 60_000, max: 100 }))
app.use(WpressX.errorHandler())          // always last

app.set('views', 'views')             app.get('views')
app.set('view engine', 'ejs')
app.set('view cache', true)           // on by default in production
app.set('trust proxy', 1)             // true | number | list | 'loopback' | fn
app.set('etag', 'weak')               // 'weak' | 'strong' | false | fn
app.set('query parser', 'extended')   // 'extended' | 'simple' | false | fn
app.set('json spaces', 2)
app.set('jsonp callback name', 'callback')
app.set('subdomain offset', 2)
app.set('x-powered-by', false)        // hide the X-Powered-By header
app.enable('strict routing')          // app.enable / app.disable / app.enabled

app.routes()
// [ { methods: ['GET'], path: '/api/todos', handlers: 1 },
//   { methods: ['GET'], path: '/api/todos/:id', handlers: 1 }, ... ]

console.log(app.summary())
// GET     /api/todos
// GET     /api/todos/:id
// POST    /api/todos

const server = app.done(3000, () => console.log('up'))   // returns http.Server
app.listen(3000)          // alias
app.start(3000)           // alias

app.address()             // the bound address, once listening
app.close(() => console.log('bye'))

// HTTPS, or anything else createServer accepts
const httpsServer = app.createServer({ key, cert })
httpsServer.listen(443)

app.get('/boom', () => {
  throw WpressX.createError(418, 'I am a teapot')
})

// createError() accepts all of these shapes
WpressX.createError(404)
WpressX.createError(404, 'Not found')
WpressX.createError(404, new Error('Not found'))
WpressX.createError(new Error('Not found'))
WpressX.createError(err, { headers: { 'X-Request-Id': id } })

// normalise anything that comes out of a callback
const err = WpressX.normalizeError(whatever)

// always last
app.use(WpressX.errorHandler())

wpress-x create my-app        # scaffold a project
wpress-x routes               # print the route table of ./app.js
wpress-x serve [file]         # run an app file (default ./app.js)
wpress-x version

npm run bench           # 50k requests, 20 concurrent
node bench/bench.js --n 20000 -c 50

const WpressX = require('wpress-x')
const app = WpressX({ views: './views', viewEngine: 'ejs', env: 'production' })

WpressX.version          // '2.0.0'
WpressX.Router(opts)     // a new Router
WpressX.Application      // the Application class
WpressX.request          // the request prototype
WpressX.response         // the response prototype
WpressX.METHODS          // the supported HTTP verbs

WpressX.Press            // aliases kept for older names
WpressX.Wpress

const router = WpressX.Router({ caseSensitive: false, mergeParams: false, strict: false })

router.use(fn)
router.get(path, ...fn)
router.route(path).get(fn).post(fn)
router.param(name, fn)
router.all(path, ...fn)
router.del(path, fn)          // alias of router.delete

WpressX.createError(status, message?)     // build an HttpError
WpressX.normalizeError(anything)          // coerce into an Error
WpressX.HttpError                         // the error class
WpressX.mime.lookup('.png')               // 'image/png'
WpressX.qs.parse('a[b]=1')                // { a: { b: '1' } }
WpressX.etag(buffer)                      // strong ETag
WpressX.pathToRegexp('/u/:id')            // { regexp, keys }
WpressX.sign(value, secret)               // signed-cookie helpers
WpressX.unsign(value, secret)
WpressX.utils                             // the whole utility bag
WpressX.middleware                        // every middleware module, untouched
WpressX.engines                           // every built-in view engine

import WpressX, { Request, Response, NextFunction, Router } from 'wpress-x'

const app = WpressX()

app.get('/users/:id', (req: Request, res: Response) => {
  res.json({ id: req.params.id })
})

app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
  res.status(500).json({ error: err.message })
})

const router: Router = WpressX.Router()
app.use('/api', router)

- const express = require('express')
- const bodyParser = require('body-parser')
- const morgan = require('morgan')
- const helmet = require('helmet')
- const cors = require('cors')
+ const WpressX = require('wpress-x')

- const app = express()
+ const app = WpressX()

- app.use(bodyParser.json())
+ app.use(WpressX.json())