Express node js

Kickstart NodeJS
Yashprit Singh
@yashprit

Agenda
1. Middleware Concept
2. Connect Middleware with Example
3. Express Middleware.
4. Express Philosophy.
5. Express Cool Features.

What is Middleware in NodeJS ?
The middleware is called as a chain of functions, with order based on middleware
definition order(time) with matching routes (if applicable).
e.g. req and res objects are travelling through chain so you can
reuse/improve/modify data in them along the chain.
/* This is only for demonstration purpose*/
function(req, res, next) {
req.name = “samething”;
next(/* err and/or output */)
}

Middleware cont.
This is sometime also called as Pipelines. Pipelines are everywhere, under
various forms, uses and purposes. Generically, a Pipeline is a series of processing
units connected together, where the output of one unit is the input for the next one.
(In Node.js, this often means a series of functions in the form.)
If your middleware should return a response, just do so. If it shouldn't, it's implied
that some later middleware should return a response. If you need to pass along
data to that later part of the process, you should attach it to an appropriate part of
the request object req.
P.S. Don’t confuse here about pipe(), thats belongs to another hero streams, streams are better
suited to process flowing data

Middleware cont.
For example,
1. The bundled bodyParser middleware is responsible for populating req.
rawBody and req.body based on the contents of the request body.
2. The bundled basicAuth middleware populates req.remoteUser based on the
HTTP authentication.

Middleware Cont.
Two general use cases for middleware :-
● Generic :- it will apply to every single request. Each middleware have to call
next() inside, if it wants to proceed to next middleware.
● Specific :- When you use app.get('/path', function(...) this actual function is
middleware as well, just inline defined
The chain order is based on definition order. So it is important to define
middleware in sync manner or order-reliable async manner. Otherwise different
order of middleware can break logic.

Middleware : Connect
● Node.js itself offers an HTTP module, whose createServer method returns an
object that you can use to respond to HTTP requests.
● That object inherits the http.Server prototype.

Connect Middleware
From the README:
Connect is an extensible HTTP server framework for node, providing high
performance "plugins" known as middleware.
More specifically, connect wraps the Server, ServerRequest, and
ServerResponse objects of node.js' standard httpmodule, giving them a few nice
extra features, one of which is allowing the Server object to use a stack of
middleware.

Connect Middleware Framework
● Connect has 18 bundled middleware and a rich selection of 3rd-party
middleware..
● That's why Connect describes itself as a "middleware framework," and is
often analogized to Ruby's Rack.

Example : Creating Simple Middleware
function uselessMiddleware(req, res, next) {
next()
}
A middleware can also signal an error by passing it as the first argument to next:
// A middleware that simply interrupts every request
function worseThanUselessMiddleware(req, res, next) {
next("Hey are you busy?")
}
When a middleware returns an error like this, all subsequent middleware will be
skipped until connect can find an error handler.

Adding middleware stack for server
To add a middleware to the stack of middleware for a server, we use it like so:
connect = require('connect')
stephen = connect.createServer()
stephen.use(worseThanUselessMiddleware)
Finally, you can also specify a path prefix when adding a middleware, and the
middleware will only be asked to handle requests that match the prefix:
connect = require('connect')
bob = connect.createServer()
bob.use('/attention', worseThanUselessMiddleware)

URL based authentication policy
function authenticateUrls(urls /* basicAuth args*/) {
basicAuthArgs = Array.slice.call(arguments, 1)
basicAuth = require('connect').basicAuth.apply(basicAuthArgs)
function authenticate(req, res, next) {
// Warning! assumes that urls is amenable to iteration
for (var pattern in urls) {
if (req.path.match(pattern)) {
basicAuth(req, res, next)
return
}
}
next()
}
return authenticate
}

Role base authorization
function authorizeUrls(urls, roles) {
function authorize(req, res, next) {
for (var pattern in urls) {
if (req.path.match(pattern)) {
for (var role in urls[pattern]) {
if (users[req.remoteUser].indexOf(role) < 0) {
next(new Error("unauthorized"))
return
}
}
}
}
next()
}
return authorize
}

Error handling
email = require('node_mailer')
function emailErrorNotifier(generic_opts, escalate) {
function notifyViaEmail(err, req, res, next) {
if (err) {
var opts = {
subject: "ERROR: " + err.constructor.name,
body: err.stack,
}
opts.__proto__ = generic_opts
email.send(opts, escalate)
}
next()
}
}

Putting it all together
private_urls = {
'^/attention': ['coworker', 'girlfriend'],
'^/bank_balance': ['me'],
}
roles = {
stephen: ['me'],
erin: ['girlfriend'],
judd: ['coworker'],
bob: ['coworker'],
}
passwords = {
me: 'doofus',
erin: 'greatest',
judd: 'daboss',
bob: 'anachronistic discomBOBulation',
}
function authCallback(name, password) {
return passwords[name] === password
}
stephen = require('connect').createServer()
stephen.use(authenticateUrls(private_urls,
authCallback))
stephen.use(authorizeUrls(private_urls, roles))
stephen.use('/attention',
worseThanUselessMiddleware)
stephen.use(emailErrorNotifier({to:
'stephen@betsmartmedia.com'}))
stephen.use('/bank_balance', function (req, res,
next) {
res.end("Don't be Seb-ish")
})
stephen.use('/', function (req, res, next) {
res.end("I'm out of coffee")
})

List of common uses connect middlewares
● logger request logger with custom format
support
● csrf Cross-site request forgery protection
● compress Gzip compression middleware
● basicAuth basic http authentication
● bodyParser extensible request body parser
● json application/json parser
● multipart multipart/form-data parser
● timeout request timeouts
● cookieParser cookie parser
● session session management support with
bundled MemoryStore
● cookieSession cookie-based session support
● methodOverride faux HTTP method support
● favicon efficient favicon server (with default
icon)
● query automatic querystring parser, populating
req.query
● errorHandler flexible error handler

Middleware: Express
Express does to Connect what Connect does to the http module: It offers a
createServer method that extends Connect's Server prototype. So all of the
functionality of Connect is there,plus view rendering and a handy DSL for
describing routes. Ruby's Sinatra is a good analogy.

Philosophy behind ExpressJS
This is probably one of the most popular frameworks in the Node.js community of
coders right now. The core philosophy behind ExpressJS is to offer an application
framework for single or multi-page web apps, using views and template engine.
The Express.js framework also includes a multitude of utilities to work with HTTP
and building APIs. The pluggable middleware in the framework provides a great
way to add elements, such as passportjs, as you need them.

Cool feature 1: routing
Routing is a way to map different
requests to specific handlers.
var express = require("express");
var http = require("http");
var app = express();
app.all("*", function(request, response, next) {
response.writeHead(200, { "Content-Type":
"text/plain" });
next();
});
app.get("/", function(request, response) {
response.end("Welcome to the homepage!");
});
app.get("/about", function(request, response) {
response.end("Welcome to the about page!");
});
app.get("*", function(request, response) {
response.end("404!");
});
http.createServer(app).listen(1337);

Cool feature 2: request handling
Express augments the request and response objects that you're passed in every
request handler.
response.redirect("/hello/anime");
response.redirect("http://www.myanimelist.net");
response.redirect(301, "http://www.anime.org"); // HTTP status code 301
This isn't in vanilla Node and it's also absent from Connect, but Express adds this
stuff. It adds things like sendFile which lets you just send a whole file:
response.sendFile("/path/to/anime.mp4");
The request gets a number of cool properties, like request.ip to get the IP address
and request.files to get uploaded files.

Cool feature 3: views
More features? Oh, Express, I'm blushing.
Express can handle views. It's not too bad. Here's what the setup looks like:
// Start Express
// Set the view directory to /views
app.set("views", __dirname + "/views");
// Let's use the Jade templating language
app.set("view engine", "jade");
The first block is the same as always. Then we say "our views are in a folder
called 'views'".

Bonus cool feature: everything from
Connect and Node
I want to remind you that Express is built on top of Connect which is built on top of
Node. This means that all Connect middleware works with Express. This is useful!
For example:
app.use(express.logger()); // Inherited from Connect
app.get("/", function(req, res) {
res.send("anime");
});
app.listen(1337);

Folder Structure : My Preference
/public
/images (there are several images exported from Photoshop)
/javascripts
/stylesheets
/style.css
/style.less (imports home.less and inner.less)
/routes
/index.js
/app
/views
/index.ejs (home page)
/inner.ejs (template for every other page of the site)
/controller
/model
/app.js
/package.json

MVC in Express
var express = require('express');
,app = express()
,fs = require('fs')
// database connection
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/mydb');
// some environment variables
app.set('port', process.env.PORT || 3000);
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.use(app.router);
app.use(express.static(path.join(__dirname,
'public')));
// dynamically include routes (Controller)
fs.readdirSync('./controllers').forEach(function
(file) {
if(file.substr(-3) == '.js') {
route = require('./controllers/' + file);
route.controller(app);
}
});
http.createServer(app).listen(app.get('port'),
function(){
console.log('Express server listening on port ' +
app.get('port'));
});

NodeJS HTTP Abstraction
Express wonderfull middleware
Philosophy behind ExpressJS
MVC in NodeJS
http://evanhahn.com/understanding-express/

NodeJS HTTP Abstraction
http://stackoverflow.com/questions/5284340/what-is-node-js-connect-express-and-
middleware
http://expressjs.com/guide.html
https://github.com/senchalabs/connect
http://stackoverflow.com/questions/17750308/middleware-design-pattern-in-node-
js-connect
http://expressjs.com/2x/guide.html#middleware
http://stackoverflow.com/questions/6893876/nodejs-and-connect-next-functionality
http://www.mariocasciaro.me/the-strange-world-of-node-js-design-patterns
http://philsversion.com/2011/08/24/lessons-learnt-from-my-first-node-js-project/
http://stella.laurenzo.org/2011/03/bulletproof-node-js-coding/

http://code.tutsplus.com/tutorials/meet-the-connect-framework--net-31220
http://stephensugden.com/middleware_guide/
http://howtonode.org/connect-it

Express node js

More Related Content

What's hot

Similar to Express node js

Recently uploaded

Express node js