Question

Here are three pieces of terminology used in documentation relating to ConnectJS for NodeJS that keeps getting used, but that I don’t completely undertand:

1) views and controllers

2) partials and collections

3) Middleware

Answer 1

Let’s start from the bottom up.

Level 0: built-in http module

In the beginning, there is node.js’s built-in http.Server written by Ryan Dahl. You write a function(req, res), and Node will call your function each time a new connection is accepted:

// Hello world HTTP server using http module:
var http = require('http');
var app = http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello, world.');
});
app.listen(8080, '127.0.0.1');

Level 1: Connect

Connect, written by Tim Caswell, is simply a subclass of http.Server that makes it easier to organize your code. Instead of writing a single callback that handles every request, you chain together some middleware. Each middleware is a function(req, res, next) that handles the request if possible, or calls next(error) if it did not finish handling the user’s request. The middleware handlers are called in the order of their use; you should call the catch-all app.use(connect.errorHandler()) at the end.

One important middleware is the router, which allows you to filter some middleware based on a pattern of the URL path. The syntax for the route patterns is based on ruby’s Sinatra routes. When I use the filter /hello/:name, req.params.name will be set to the matching part of the URL.

var connect = require('connect');
var app = connect.createServer();
app.use(connect.favicon());
app.use(connect.logger());,
app.use(connect.router(function(app) {
  app.get('/hello/:name', function(req, res, next) {
    try {
      if (Math.random() > 0.5) {
        throw new Error('Random error!');
      }
      res.writeHead(200, {'Content-Type': 'text/plain'});
      res.end('Hello, ' + req.params.name);
    } catch (e) {
      return next(e);
    }
  });
}));
app.listen(8080, '127.0.0.1');

In Connect, every handler is middleware! You use whichever functionality you need like bodyParser or cookieParser, and your own business logic is also a middleware function with the same signature function(req, res, next). The connect homepage gives a list of the built-in middleware.

Level 2: Express.js

Express’s http server, written by TJ Holowaychuk, is in turn a subclass of Connect that forces the Sinatra style more. In Connect, there was no magic you didn’t ask for, but in Express, the router and qs parser (which sets req.query) are automatically used. The router syntax is cleaned up; you call app.get, app.post, etc. directly (and the router is positioned at the first call) rather than putting them inside a function.

Express also contains many other well-documented features and helper functions to extend app, req, and res.

One feature of Express is res.render, which renders the given template file (relative to app.set('views') or $PWD/views) using the template engine implied by the extension, and res.partial, which calls render on each element of a collection (which is just any arraylike object). But I haven’t used this optional feature; if you don’t care for express’s templates you can just res.send data yourself.