Middleware to minify HTML output for express template render engines in which supports callbacks

index.js

/* app/controllers/index.js */

module.exports.index = function(req, res) {
    res.render('index.html');
};

render-minified.js

/* config/middlewares/render-minified.js */

/**
* Dependencies
*/

var Minifier = require('html-minifier');

/**
* Render with minified HTML (express + nunjucks)
*   Works as a response.method that minifies html string
*   after nunjucks.render compiles and callback
* @param {String} view
* @param {Object} options
*/

module.exports = exports = function(req, res, next) {
    res.oldRender = res.render;
    res.render = function(view, options) {
        this.oldRender(view, options, function(err, html) {
            if (err) throw err;
            html = Minifier.minify(html, {
                removeComments: true,
                removeCommentsFromCDATA: true,
                collapseWhitespace: true,
                collapseBooleanAttributes: true,
                removeAttributeQuotes: true,
                removeEmptyAttributes: true
            });
            res.send(html);
        });
    };
    next();
};

server.js

/* server.js */

var express = require('express'),
    nunjucks = require('nunjucks'),
    renderMinified = require('./app/config/middlewares/render-minified');

var app = express();

app.engine('html', nunjucks.render);
nunjucks.configure(env.views, {
    autoescape: true,
    express: app
});

// new response render which passes html-minifier as callback to express render engine
app.use(renderMinified);

test-render-minified.js

/* global describe, it, before */

/* tests/middlewares/render-minified.js */
/* by @rafaelverger */

var assert = require('assert'),
    sinon = require('sinon'),
    renderMinified = require('../../app/config/middlewares/render-minified');

describe('render-minified.js', function(){

    var renderSpy,
        renderNextSpy,
        resMock;

    before(function() {
        renderSpy = sinon.spy();
        renderNextSpy = sinon.spy();
        resMock = {render: renderSpy};
        renderMinified({}, resMock, renderNextSpy);
    });

    it ('ensure response.render was overwritten by renderMinified module', function() {
        assert(renderSpy !== resMock.render);
        assert(renderSpy === resMock.oldRender);
        assert(renderNextSpy.calledOnce);
        assert(renderNextSpy.calledWithExactly());
    });

    it('ensure the new render function calls old one', function() {
        var a = "index.html",
            b = {foo: 'bar'};

        resMock.render(a, b);
        assert(renderSpy.calledOnce);
        assert(renderSpy.calledWith(a, b));
    });
});

For line 12 of render-minified.js I has to use if (err) return next(err); otherwise my error handling didn't work!