A quick http server framework. ES6 async/await and ECMAScript modules.

Features:

• ECMAScript modules.
• Latest javascript features.
• Support for global fetch.
• Built in support for using dot env files.
• Built in configurable headers.
• Built in logger.
• Support for file-based routing.
• Can add replacer to file-based routing.
• Async/Await.
• Centralized error handling.

Table of Contents

• Installation
• Getting Started
  • Configuration File
  • Constructor
• Middleware
• Neumatter/App
  • (method) neumatter.use
  • (method) neumatter.useMany
  • (method) neumatter.listen
  • (method) neumatter.listener
  • (method) neumatter.init
  • (method) neumatter['METHOD']
  • (method) Neumatter.load
  • (prop) Neumatter.Logger
  • (prop) Neumatter.Router
  • (getter) Neumatter.serverOptions
• NeuRouter
  • constructor
  • (method) router.route
  • (method) router.transmitter
  • (method) router['METHOD']
• NeuRoute
  • constructor
  • (method) route['METHOD']
• NeuRequest
  • (method) request.get
  • (method) request.emitErr
  • (method) request.isValidEmail
  • (getter) request.protocol
  • (getter) request.isSecure
  • (getter) request.host
  • (getter) request.hostname
  • (getter) request.port
  • (getter) request.path
  • (getter) request.query
  • (getter) request.href
  • (getter) request.ip
  • (getter) request.URL
  • (getter) request.searchParams
  • (prop) request.params
  • (prop) request.app
• NeuResponse
  • (method) response.get
  • (method) response.set
  • (method) response.status
  • (method) response.redirect
  • (method) response.send
  • (method) response.json
  • (method) response.html
  • (method) response.download
  • (method) response.file
  • (method) response.render
  • (getter) response.sent
  • (getter) response.isHead
  • (getter) response.hasContentLength
  • (prop) response.hasType
  • (prop) response.locals
  • (prop) response.viewer

Install

1npm i neumatter --save

Getting Started

There are two options, using a configuration file or by using the constructor.

Configuration File: neumatter.config.json in root folder.

"env" is the options object, that will be passed to the constructor. "routes" required. path to routes/pages directory. "middleware" optional. path to middleware directory.

1{
2  "env": {
3    "port": 8080,
4    "static": "./public",
5    "viewer": {
6      "views": "./views",
7      "blocks": "./views/blocks",
8      "layouts": "./views/layouts"
9    }
10  },
11  "middleware": "./server/middleware",
12  "routes": "./server/routes"
13}

1import Neumatter from 'neumatter'
2
3// loads the configuration and returns Promise<Neumatter>
4const app = await Neumatter.load()
5
6app.listen()

Constructor:

Options:

• parseMethod: string Method that will be used to parse NeuRequest.body.
• errorMiddleware: function Error Handler.
• proxy: boolean Trust proxy.
• env: string Often set as 'development' or 'production'.
• port: number Port that the application will use.
• host: string Hostname.
• static: string Path to static folder that will be scoped to '/'.
• context: object User defined object, that adds context to application.
• configureHeaders: object
• views: string Path to view folder.
• viewer: object
• viewer.views: string Path to views folder.
• viewer.layouts: string Path to layouts folder.
• viewer.defaultData: object User defined object, that adds data by default to a rebdered view.
• logger: object
• logger.name: string Name of the logger.
• logger.dir: string Path to folder to hold logs.
• logger.cacheSize: number Max size of logs to cache before writing to logs.
• logger.virtual: boolean If logger is virtual only.
• logger.json: boolean If logger should use json.

1import Neumatter from 'neumatter'
2
3const app = new Neumatter()
4
5app.get('/', (req, res) => {
6  res.send('Hello World')
7})
8
9app.listen()

Adding Routers & Middleware:

1import Neumatter from 'neumatter'
2import productRouter from './routes/products.js'
3import productMiddlewareFn from './middleware.js'
4import middlewareFn from './middleware.js'
5
6const app = new Neumatter()
7
8await app.use({
9  middleware: [middlewareFn]
10})
11
12await app.use({
13  path: '/products',
14  middleware: [productMiddlewareFn],
15  router: productRouter
16})
17
18app.listen()

Middleware

MiddlewareFn: (request, response, next)

• request: NeuRequest
• response: NeuResponse
• next: NextFunction

1const middlewareFn = (req, res, next) => {
2  // do something
3  next() // call NextFunction
4}

ResponseFn: (request, response, next?)

• request: NeuRequest
• response: NeuResponse
• next: NextFunction

1const responseFn = (req, res) => {
2  // do something
3  res.json({ data: 'Hello World!' }) // send response
4}

Neumatter/App

neumatter.use(data: { path?, middleware, router? })

• data.path: string|null
• data.middleware: Array<MiddlewareFn>
• data.router: NeuRouter

1import Neumatter from 'neumatter'
2import productRouter from './routes/products.js'
3
4const app = new Neumatter()
5
6const middlewareFn = (req, res, next) => {
7  // do something
8  next() // call NextFunction
9}
10
11await app.use({
12  middleware: [middlewareFn]
13})
14
15await app.use({
16  path: '/products',
17  middleware: [middlewareFn],
18  router: productRouter
19})

neumatter.useMany(prop: [data: { path?, middleware, router? }])

• prop: Array<data>
• data.path: string|null
• data.middleware: Array<MiddlewareFn>
• data.router: NeuRouter

1import Neumatter from 'neumatter'
2import productRouter from './routes/products.js'
3
4const app = new Neumatter()
5
6const middlewareFn = (req, res, next) => {
7  // do something
8  next() // call NextFunction
9}
10
11await app.useMany([
12  {
13    middleware: [middlewareFn]
14  },
15  {
16    path: '/products',
17    middleware: [middlewareFn],
18    router: productRouter
19  }
20])

neumatter.listen(options?: { port?, host? })

• options.port: number Port that the server will run on.
• options.host: string Set the servers host. Defaults to localhost.

neumatter.listener()

The function that will be called on server requests. Creating a server and using the function manually will skip the neumatter.init function.

1import Neumatter from 'neumatter'
2import http from 'http'
3
4const app = new Neumatter()
5
6const server = http.createServer(Neumatter.serverOptions, app.listener())

neumatter.init(serverFn)

• serverFn: typeof http.createServer

1import Neumatter from 'neumatter'
2import http from 'http'
3
4const app = new Neumatter()
5
6const server = app.init(http.createServer)

neumatter['METHOD'](path, middlewareFn|responseFn)

• path: string Path for url lookup.
• middlewareFn|responseFn: MiddlewareFn|Array<MiddlewareFn>|ResponseFn
• METHODS:
  • get
  • post
  • put
  • patch
  • trace
  • options
  • connect
  • delete

1import Neumatter from 'neumatter'
2import http from 'http'
3
4const app = new Neumatter()
5
6app.get('/', (req, res) => {
7  res.json({ data: 'Hello World!' })
8})
9
10app.post('/page',
11  (req, res, next) => {
12    if (!req.body.name) res.redirect('/')
13    next()
14  },
15  (req, res) => {
16    // do something
17    res.send('success')
18  }
19)

Neumatter.load()

The function to load the configuration file and return the application.

1import Neumatter from 'neumatter'
2
3const app = await Neumatter.load()
4
5app.listen()

Neumatter.Logger

The class that can be used to create a new Logger instance.

1import Neumatter from 'neumatter'
2
3const logger = new Neumatter.Logger({ virtual: true })

Neumatter.Router

The class that can be used to create a new Router instance.

1import Neumatter from 'neumatter'
2
3const router = new Neumatter.Router()