Version 1.0.0 all tests pass

Author: ebdrup

.gitignore

@@ -0,0 +1,24 @@
+node_modules
+
+*.seed
+*.log
+*.dat
+*.out
+*.pid
+*.gz
+*~
+.idea
+*.sublime-project
+*.sublime-workspace
+*.orig
+
+pids
+logs
+results
+
+npm-debug.log
+
+.coverage
+coverageReport.html
+
+

.jshintignore

@@ -0,0 +1,43 @@
+{
+    "predef": [
+        "sinon",
+        "_",
+        "requireMockFactory",
+        "it",
+        "describe",
+        "expect",
+        "beforeEach",
+        "before",
+        "after",
+        "afterEach"
+    ],
+
+    "node" : true,
+    "boss" : false,
+    "curly": true,
+    "debug": false,
+    "devel": false,
+    "eqeqeq": true,
+    "evil": false,
+    "forin": false,
+    "immed": true,
+    "laxbreak": false,
+    "newcap": true,
+    "noarg": true,
+    "noempty": false,
+    "nonew": true,
+    "onevar": false,
+    "plusplus": false,
+    "multistr": true,
+    "regexp": false,
+    "undef": true,
+    "sub": false,
+    "strict": true,
+    "bitwise" : true,
+    "curly" : true,
+    "latedef" : false,
+    "noarg" : true,
+    "trailing" : true,
+    "asi" : false,
+    "expr": true
+}

.jshintrc

@@ -0,0 +1,29 @@
+node_modules
+
+*.seed
+*.log
+*.dat
+*.out
+*.pid
+*.gz
+*~
+.idea
+*.sublime-project
+*.sublime-workspace
+*.orig
+
+pids
+logs
+results
+
+npm-debug.log
+
+.coverage
+coverageReport.html
+
+test
+bin
+.gitignore
+.jshintignore
+.jshintrc
+.npmignore

.npmignore

@@ -0,0 +1,21 @@
+"use strict";
+process.env.NODE_ENV = "coverage";
+var fs = require("fs");
+
+//make writes to stdout and stderr sync, so the process does not exit before writing output.
+process.stdout.write = function (data){
+	fs.writeSync(1, data);
+};
+process.stderr.write = function (data){
+	fs.writeSync(2, data);
+};
+
+var nodecoverage = require("nodecoverage");
+nodecoverage({
+	instrument:["lib"]
+}, function (err) {
+	if(err){
+		console.error(err);
+	}
+	process.exit();
+});

bin/runCoverage.js

@@ -0,0 +1,40 @@
+"use strict";
+var fs = require("fs");
+var path = require("path");
+
+//make writes to stdout and stderr sync, so the process does not exit before writing output.
+process.stdout.write = function (data){
+	fs.writeSync(1, data);
+};
+process.stderr.write = function (data){
+	fs.writeSync(2, data);
+};
+
+runJsHint(["lib", "test", "bin"], function (err) {
+	if (err) {
+		console.error("Exiting because of jsHint errors");
+		return process.exit(1);
+	}
+	console.log("No JSHint errors detected");
+	return runMocha();
+});
+
+function runMocha() {
+	require('../node_modules/mocha/bin/_mocha');
+}
+
+function runJsHint(pathsArray, callback) {
+	var jsHint = require("../node_modules/jshint/lib/hint.js");
+	var config = JSON.parse(fs.readFileSync(path.resolve(".jshintrc"), "utf-8"));
+	var reporter = require("../node_modules/jshint/lib/reporters/default.js").reporter;
+	var ignores = fs.readFileSync(path.resolve(".jshintignore"), "utf8").split("\n")
+		.filter(function (line) {
+			return !!line.trim(); //remove empty lines
+		})
+		.map(path.resolve);
+	var results = jsHint.hint(pathsArray, config, reporter, ignores);
+	if (results.length > 0) {
+		return callback(new Error("JSHintErrors"));
+	}
+	return callback(null);
+}

bin/runTests.js

@@ -0,0 +1,15 @@
+"use strict";
+var errors = require("./nodeerrors");
+module.exports = function(options){
+
+	return errorHandler;
+
+	function errorHandler(req, res, next, err){
+		var error = errors.parse(err);
+		req.error = JSON.parse(JSON.stringify(error)); //for logging of internal messages by logger
+		res.statusCode = error.http;
+		delete error.http; //do not show http code to users (it's send in header)
+		delete error.internal; //do not show internal messages to users
+		res.json(error);
+	}
+};

lib/middleware.js

@@ -0,0 +1,54 @@
+"use strict";
+var _ = require("underscore");
+var errorCodeSpecs = require("./util/getErrorConfig");
+var makeErrorFunction = require("./util/makeErrorFunction");
+var parse = require("./util/parse");
+var getSerializableError = require("./util/getSerializableError");
+var middleware = require("./middleware");
+
+var nodeError = {
+	errorCodes:{},
+	parse:parse,
+	middleware:middleware
+};
+
+var functionsToMake = _.keys(errorCodeSpecs); //get array of freindly names.
+for (var i = 0; i < functionsToMake.length; i++) {
+	//get error code freindly name, for example: "internalError"
+	var errorCodeName = functionsToMake[i];
+	//make error function for freindly name
+	nodeError[errorCodeName] = makeErrorFunction(errorCodeName, errorCodeSpecs[errorCodeName]);
+	//save the error code in errorCodes
+	nodeError.errorCodes[errorCodeName] = errorCodeSpecs[errorCodeName].code;
+}
+
+Error.prototype.innerError = function addInnerError(err) {
+	var error;
+	try {
+		error = JSON.parse(this.message);
+	} catch (ex) {
+		error = {
+			message:this.message
+		};
+	}
+	error.internal = error.internal || {};
+	error.internal.innerError = getSerializableError(err);
+	this.message = JSON.stringify(error);
+	return this;
+};
+
+Function.prototype.onError = function (callback) {
+	var fn = this;
+	return function (err) {
+		if (err) {
+			return callback(err);
+		}
+		try {
+			fn.apply(null, arguments);
+		} catch (ex) {
+			return callback(ex);
+		}
+	};
+};
+
+module.exports = nodeError;

lib/nodeerrors.js

@@ -0,0 +1,34 @@
+"use strict";
+var _ = require("underscore");
+var path = require("path");
+var fs = require("fs");
+var existsSync = fs.existsSync || path.existsSync;
+var CONFIG_FILE_NAME = ".errors.js";
+
+function requireConfig() {
+	var dir = path.join(__dirname, "../..");
+	var lastDir;
+
+	while (lastDir !== dir) {
+		if (existsSync(path.join(dir, CONFIG_FILE_NAME))) {
+			return require(path.join(dir, CONFIG_FILE_NAME));
+		}
+		if (existsSync(path.join(dir, "config", CONFIG_FILE_NAME))) {
+			return require(path.join(dir, "config", CONFIG_FILE_NAME));
+		}
+		lastDir = dir;
+		dir = path.join(dir, "..");
+	}
+	return {};
+}
+var config = JSON.parse(JSON.stringify(requireConfig())); //make copy so we do not alter original
+if (!config.system) {
+	config.system = {
+		code:0,
+		message:"There was an internal server error",
+		http:500
+	};
+}
+
+module.exports = config;
+

lib/util/getErrorConfig.js

@@ -0,0 +1,11 @@
+"use strict";
+module.exports = function getSerializableError(err) {
+	//this copying of properties is needed to get Error properties serialized by JSON.stringify
+	var output = {};
+	Object.getOwnPropertyNames(err).forEach(function (i) {
+		if (err[i]) {
+			output[i] = err[i];
+		}
+	});
+	return output;
+};

lib/util/getSerializableError.js

@@ -0,0 +1,43 @@
+"use strict";
+var format = require("util").format;
+
+module.exports = function makeErrorFunction(errorCodeName, errorCodeSpec) {
+	if (!errorCodeSpec.code && errorCodeSpec.code !== 0) {
+		throw new Error(format("The error code specification for %s, has no property 'code'", errorCodeName));
+	}
+
+	return function () {
+		var error = {}, message;
+		error.name = errorCodeName;
+		var i = 0;
+		if (errorCodeSpec.args) {
+			for (i = 0; i < errorCodeSpec.args.length; i++) {
+				var argName = errorCodeSpec.args[i];
+				if (arguments[i]) {
+					error[argName] = arguments[i];
+				}
+			}
+		}
+		if(arguments[i]){
+			error.internal = arguments[i]; //always allow additional last argument to be stored as internal
+		}
+		//get error message
+		if (errorCodeSpec.args) {
+			var formatArguments = [errorCodeSpec.message];
+			formatArguments.push.apply(formatArguments, arguments);
+			message = format.apply(format, formatArguments);
+		} else {
+			message = errorCodeSpec.message;
+		}
+		error.message = message;
+		//add additional error code spec properties
+		var properties = _.keys(errorCodeSpec);
+		for(i=0; i<properties.length; i++){
+			var propertyName = properties[i];
+			if(propertyName !== "args" && propertyName !== "message"){
+				error[propertyName] = errorCodeSpec[propertyName];
+			}
+		}
+		return new Error(JSON.stringify(error));
+	};
+};

lib/util/makeErrorFunction.js

@@ -0,0 +1,19 @@
+"use strict";
+var _ = require("underscore");
+var getSerializableError = require("./getSerializableError");
+
+module.exports = function parseError(err) {
+	var errors = require("../nodeerrors.js");
+	var error;
+	try {
+		error = JSON.parse(err.message);
+		error.internal =  error.internal || {};
+		_(error.internal).extend(getSerializableError(err)); //add call stack from Error object
+		delete error.internal.message; //no need to keep JSON string, it has been de-serialized in to error object.
+		return error;
+	} catch (ex) {
+		//this is not one of our errors, must be from mongo or somewhere else, no recovery possible.
+		return parseError(errors.system().innerError(err));
+	}
+};
+

lib/util/parse.js

@@ -0,0 +1,31 @@
+{
+	"author":"Allan Ebdrup",
+	"name":"nodeerrors",
+	"version":"1.0.0",
+	"repository":{
+		"type":"git",
+		"url":"https://github.com/Muscula/nodeerrors"
+	},
+	"private":false,
+	"main":"./lib/nodeerrors.js",
+	"engines":{
+		"node":">=0.6.20",
+		"npm":">=1.1.9"
+	},
+	"dependencies":{
+		"underscore":"~1.3.1"
+	},
+	"scripts":{
+		"test":"node ./bin/runTests.js",
+		"cov":"node ./bin/runCoverage.js"
+	},
+	"devDependencies":{
+		"mocha":"",
+		"chai":"",
+		"sinon":"",
+		"sinon-chai":"",
+		"jshint":"",
+		"nodecoverage":">=0.6.5",
+		"requiremock": ">=1.3.3"
+	}
+}