There are a lot of node.js frameworks, and even some inspired by ruby on rails, but to my knowledge there is still no framework that brings the same conventions and ease of new application development to node. A saga...
Head to the wiki for full documentation.
This is a quick glance at some of the niceties provided by nexi. For a deep dive into all of the bells and whistles, check out the docs
Nexi is a mvc web framework that is designed to provide a foundation for building applications that scale cleanly and easily.
Nexi controllers are fairly simple, and combined with several other conventions provide a very easy means to adding new pages or api endpoints to your application.
// src/app/controllers/home-controller.js
const { BaseController } = require('nexi')
class HomeController extends BaseController {
async welcome(req, res) {
const user = this.context.models.users.findOne({ id: req.params.id })
return res.render('home/welcome', { user } )
}
}
module.exports = WelcomeController
Modeled after rails routes, the router is simple yet powerful providing one organized space to declare all of your applications routes cleanly. The router hooks into Nexi middleware enabling an easy way to configure per route (or a group of routes) pre/post request handlers. Namespace blocks and inline handlers are also supported.
// src/routes.js
module.exports = (context, router) => {
router.get('/welcome/:id', 'homeController#welcome')
router.get('/secret', 'requireLogin', 'secretController#shh')
}
Nexi comes with a templating engine (handlebars hooked up out of the box. For apis, views can be omitted through configuration. Layouts, view helpers, partials, and other common mvc view components are also provided.
// src/app/views/home/welcome.js
<div>
<h1>Welcome {{user.name}}!</h1>
</div>
Nexi also comes with an orm (waterline) as well as a fully featured migrations tool. These can also be disabled through configuration.
//src/app/models/User.js
module.exports = {
identity: 'user',
datastore: 'default',
attributes: {
name: {
type: 'string',
required: true,
},
}
}
Instead of providing Nexi components (such as models or the application configuration) as global variables, Nexi exposes these components through a context (see context design pattern) object injected into and accessible within any Nexi hook (controllers, middleware, decorators, initializers). This provides simple dependency injection pattern that promotes reusability, testability, and maintainability.
You can also decorate context with anything you'd like to be globally available.
//src/decorators/index.js
module.exports = (context) => {
context.elasticSearchClient = new elasticsearch.Client()
}
...
const results = await this.context.elasticSearchClient.search(params)
- Middleware - Easy to add global pre/post request middleware along with router middleware make it easy to controller the request flow
- Built in middleware - Request logging, error responses, global exception handlers, security, compression
- Built in decorators - models, error reporter, application logger, application configuration
- Initializers & bootstrap support - handle startup logic in either
config/boot.jsor group like functionality in initializers - Sessions - session store provided out of the box