Connect

Connect is an extensible HTTP server framework for node using "plugins" known as middleware.

var connect = require('connect');
var http = require('http');

var app = connect();

// gzip/deflate outgoing responses
var compression = require('compression');
app.use(compression());

// store session state in browser cookie
var cookieSession = require('cookie-session');
app.use(cookieSession({
    keys: ['secret1', 'secret2']
}));

// parse urlencoded request bodies into req.body
var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded());

// respond to all requests
app.use(function(req, res){
  res.end('Hello from Connect!\n');
});

//create node.js http server and listen on port
http.createServer(app).listen(3000);

Getting Started

Connect is a simple framework to glue together various "middleware" to handle requests.

Install Connect

$ npm install connect

Create an app

The main component is a Connect "app". This will store all the middleware added and is, itself, a function.

var app = connect();

Use middleware

The core of Connect is "using" middleware. Middleware are added as a "stack" where incoming requests will execute each middleware one-by-one until a middleware does not call next() within it.

app.use(function middleware1(req, res, next) {
  // middleware 1
  next();
});
app.use(function middleware2(req, res, next) {
  // middleware 2
  next();
});

Mount middleware

The .use() method also takes an optional path string that is matched against the beginning of the incoming request URL. This allows for basic routing.

app.use('/foo', function fooMiddleware(req, res, next) {
  // req.url starts with "/foo"
  next();
});
app.use('/bar', function barMiddleware(req, res, next) {
  // req.url starts with "/bar"
  next();
});

Error middleware

There are special cases of "error-handling" middleware. There are middleware where the function takes exactly 4 arguments. Errors that occur in the middleware added before the error middleware will invoke this middleware when errors occur.

app.use(function onerror(err, req, res, next) {
  // an error occurred!
});

Create a server from the app

The last step is to actually use the Connect app in a server. The .listen() method is a convenience to start a HTTP server.

var server = app.listen(port);

The app itself is really just a function with three arguments, so it can also be handed to .createServer() in Node.js.

var server = http.createServer(app);

Middleware

These middleware and libraries are officially supported by the Connect/Express team:

body-parser - previous bodyParser, json, and urlencoded. You may also be interested in:
- body
- co-body
- raw-body
compression - previously compress
connect-timeout - previously timeout
cookie-parser - previously cookieParser
cookie-session - previously cookieSession
csurf - previously csrf
errorhandler - previously error-handler
express-session - previously session
method-override - previously method-override
morgan - previously logger
response-time - previously response-time
serve-favicon - previously favicon
serve-index - previously directory
serve-static - previously static
vhost - previously vhost

Most of these are exact ports of their Connect 2.x equivalents. The primary exception is cookie-session.

Some middleware previously included with Connect are no longer supported by the Connect/Express team, are replaced by an alternative module, or should be superseded by a better module. Use one of these alternatives instead:

cookieParser
- cookies and keygrip
limit
- raw-body
multipart
- connect-multiparty
- connect-busboy
query
- qs
staticCache
- st
- connect-static

Checkout http-framework for many other compatible middleware!

Running Tests

npm install
npm test

Contributors

https://github.com/senchalabs/connect/graphs/contributors

Node Compatibility

Connect < 1.x - node 0.2
Connect 1.x - node 0.4
Connect < 2.8 - node 0.6
Connect >= 2.8 < 3 - node 0.8
Connect >= 3 - node 0.10, 0.12; io.js 1.x, 2.x

License

MIT

htoooth / connect