Extending EventEmitter In Order To Create A Response Proxy In Node.js

// Include core libraries.
var http = require( "http" );
var events = require( "events" );


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //
// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// I am the response proxy constructor.
function ResponseProxy( response ){

	// Initialize super class properties. This will make sure that
	// two instances of the response proxy don't accidentally share
	// and event listeners.
	events.EventEmitter.call( this );

	// Store the original response object.
	this._response = response;

	// Set up the default status code.
	this._status = {
		code: 200,
		text: "OK"
	};

	// Set up the default headers collection.
	this._headers = {
		"content-type": "text/plain"
	};

	// I determine whether or not the headers have been flushed.
	this._isCommitted = false;

	// Return this object reference.
	return( this );

}

// Extend the EventEmitter class allowing us to use on() and emit()
// methods like the underlying response.
ResponseProxy.prototype = new events.EventEmitter();


// I commit the response to the client. This will flush the headers
// and flag the response as committed.
ResponseProxy.prototype._commitResponse = function(){

	// Raise the commit-start event - this will give people one last
	// hook for setting headers before they are flushed.
	this.emit( "commitStart" );

	// Flag the response as committed.
	this._isCommitted = true;

	// Write the status code.
	this._response.writeHead(
		this._status.code,
		this._status.text,
		this._headers
	);

	// Raise the commit-end event. At this point, no one can write
	// anymore headers to the response.
	this.emit( "commitEnd" );

	// Raise the response-start event. This will be the first
	// opporunity for someone to write to the output.
	this.emit( "responseStart" );

};


// I end the current response, flushing any headers and additional
// content that have not yet been committed.
ResponseProxy.prototype.end = function( data, encoding ){

	// Check to see if the current response has been committed.
	// If not, then we have to commit before we end the response.
	if (!this._isCommitted){

		// Commit the response.
		this._commitResponse();

	}

	// Check to see if any data was send with the end() request.
	// If so, we want to write it manually - this way, we can still
	// put a hook around the underlying end() request.
	if (data){

		// Write the last piece of data.
		this._response.write( data, encoding );

	}

	// Raise the response-end event. This will provide one last
	// hook for content to be written to the response.
	this.emit( "responseEnd" );

	// End the event.
	this._response.end();

	// Return this object reference for method chaining.
	return( this );

};


// I provide access to the underlying response.
ResponseProxy.prototype.getResponse = function(){

	// Return the underlying response.
	return( this._response );

};


// I add the given header name/value pair to the header collection.
ResponseProxy.prototype.setHeader = function( name, value ){

	// Store the header.
	this._headers[ name ] = value;

	// Return this object reference for method chaining.
	return( this );

};


// I set the given status code and text.
ResponseProxy.prototype.setStatus = function( code, text ){

	// Set the status code.
	this._status.code = code;
	this._status.text = (text || "");

	// Return this object reference for method chaining.
	return( this );

};


// I write data to the response, flushing any headers that have not
// yet been committed.
ResponseProxy.prototype.write = function( data, encoding ){

	// Check to see if the current response has been committed.
	// If not, then we have to commit before we write.
	if (!this._isCommitted){

		// Commit the response.
		this._commitResponse();

	}

	// Write the data to the underlying response.
	this._response.write( data, encoding );

	// Return this object reference for method chaining.
	return( this );

};


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //
// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// Create the HTTP server.
var server = http.createServer(
	function( request, response ){


		// Create a new response proxy for our response.
		var responseProxy = new ResponseProxy( response );


		// Bind the commit-start event so we can add one more header
		// before the content is flushed.
		responseProxy.on( "commitStart", function(){

			// Add one more header.
			this.setHeader( "Commit-Start", "Test event hook" );

		});

		// Bind to the response-start event so we can be the first
		// people to write to the output.
		responseProxy.on( "responseStart", function(){

			// Write the very first output data.
			this.write( "I am the very first output!\n" );

		});

		// Bind to the response-end event so we can write more
		// data to the output before the connection is closed.
		responseProxy.on( "responseEnd", function(){

			// Write one more bit of output.
			this.write( "I am the last possible output!\n" );

		});


		// -- Start using proxy directly. -- //


		// Set a header.
		responseProxy.setHeader( "Explicit-Set", "Header value." );

		// Write some output.
		responseProxy.write( "This is the inline-write.\n" );

		// End the response.
		responseProxy.end( "Ending.\n" );


	}
);

// Point the server to listen to the given port for incoming
// requests.
server.listen( 8080 );


// ---------------------------------------------------------- //
// ---------------------------------------------------------- //


// Output intialization confirmation message.
console.log( "HTTP sever is running on port 8080." );