joyrexus · June 6, 2016 23:30 · Apr 3, 2016 · Apr 3, 2016 · Apr 1, 2016 · Apr 1, 2016
diff --git a/http-errors.js b/http-errors.js
@@ -1,3 +1,4 @@
+'use strict';
 const statusCodes = require('http').STATUS_CODES;
 
 function createError(code, name) {

diff --git a/http-errors.js b/http-errors.js
@@ -1,4 +1,3 @@
-'use strict';
 const statusCodes = require('http').STATUS_CODES;
 
 function createError(code, name) {

diff --git a/node-http-errors.md b/node-http-errors.md
@@ -19,7 +19,8 @@ try {
 
 ### Features
 
-* **4xx/5xx status as errors classes** - Status text is the class name, e.g. Unauthorized, NotFound
+* **4xx/5xx status as errors classes** - Status text is the class name, e.g. UnauthorizedError, NotFoundError
+* **Status code property** - Error handlers can use the status code to send responses.
 * **Correct stack trace** - no extra stack frames, no double capturing of the stack trace
 
 ### Anti-patterns

diff --git a/node-http-errors.md b/node-http-errors.md
@@ -19,8 +19,7 @@ try {
 
 ### Features
 
-* **Name appears once** - less editing if you have to create lots of custom error classes
-* **Easy to subclass** - just change the last line to inherit from another custom error class you created
+* **4xx/5xx status as errors classes** - Status text is the class name, e.g. Unauthorized, NotFound
 * **Correct stack trace** - no extra stack frames, no double capturing of the stack trace
 
 ### Anti-patterns

diff --git a/error.md → node-http-errors.md b/error.md → node-http-errors.md
diff --git a/error.md b/error.md
@@ -1,6 +1,4 @@
-It's nice to be able to distinguish error types by classes. But it's a bit tricky to correctly create a custom error class in Node.js, so here is an example.
-
-The example also shows how to add an extra parameter called `extra` that will be stored as a property on the error.
+4xx/5xx errors with their statusCode in it.
 
 ### Usage
 
@@ -10,6 +8,13 @@ var BadRequestError = require('./http-errors').BadRequestError;
 function doSomethingBad() {
   throw new BadRequestError('It went bad!');
 }
+
+try {
+  doSomethingBad();
+} catch (err) {
+  assert.strictEqual(err.statusCode, 400);
+}
+
 ```
 
 ### Features

diff --git a/error.md b/error.md
@@ -5,10 +5,10 @@ The example also shows how to add an extra parameter called `extra` that will be
 ### Usage
 
 ``` js
-var CustomError = require('./errors/custom-error');
+var BadRequestError = require('./http-errors').BadRequestError;
 
 function doSomethingBad() {
-  throw new CustomError('It went bad!', 42);
+  throw new BadRequestError('It went bad!');
 }
 ```
 

diff --git a/http-error.js → http-errors.js b/http-error.js → http-errors.js
diff --git a/test-error.js b/test-error.js
@@ -1,7 +1,7 @@
 // Mini test suite for our 4xx/5xx error
 
 var assert = require('assert');
-var BadRequestError = require('./errors').BadRequestError
+var BadRequestError = require('./http-errors').BadRequestError
 
 function doSomethingBad() {
   throw new BadRequestError('It went bad!');

diff --git a/custom-error.js b/custom-error.js
@@ -1,10 +0,0 @@
-'use strict';
-
-module.exports = function CustomError(message, extra) {
-  Error.captureStackTrace(this, this.constructor);
-  this.name = this.constructor.name;
-  this.message = message;
-  this.extra = extra;
-};
-
-require('util').inherits(module.exports, Error);

diff --git a/http-error.js b/http-error.js
@@ -0,0 +1,21 @@
+'use strict';
+const statusCodes = require('http').STATUS_CODES;
+
+function createError(code, name) {
+  return function(message) {
+    Error.captureStackTrace(this, this.constructor);
+    this.name = name;
+    this.message = message;
+    this.statusCode = code;
+  }
+}
+
+Object.keys(statusCodes)
+  .filter(code => code >= 400)
+  .forEach(code => { 
+    let name = statusCodes[code]
+      .replace(/\W/g, '')
+      .concat('Error')
+    exports[name] = createError(Number(code), name);
+    require('util').inherits(exports[name], Error);
+  })
diff --git a/test-error.js b/test-error.js
@@ -1,43 +1,31 @@
-// Mini test suite for our custom error
+// Mini test suite for our 4xx/5xx error
 
 var assert = require('assert');
-var CustomError = require('./errors/custom-error');
+var BadRequestError = require('./errors').BadRequestError
 
 function doSomethingBad() {
-  throw new CustomError('It went bad!', 42);
+  throw new BadRequestError('It went bad!');
 }
 
 try {
   doSomethingBad();
 } catch (err) {
   // The name property should be set to the error's name
-  assert(err.name = 'CustomError');
-
+  assert(err.name = 'BadRequestError');
   // The error should be an instance of its class
-  assert(err instanceof CustomError);
-
+  assert(err instanceof BadRequestError);
   // The error should be an instance of builtin Error
   assert(err instanceof Error);
-
   // The error should be recognized by Node.js' util#isError
   assert(require('util').isError(err));
-
   // The error should have recorded a stack
   assert(err.stack);
-
   // toString should return the default error message formatting
-  assert.strictEqual(err.toString(),
-                     'CustomError: It went bad!');
-
+  assert.strictEqual(err.toString(), 'BadRequestError: It went bad!');
   // The stack should start with the default error message formatting
-  assert.strictEqual(err.stack.split('\n')[0],
-                     'CustomError: It went bad!');
-
+  assert.strictEqual(err.stack.split('\n')[0], 'BadRequestError: It went bad!');
   // The first stack frame should be the function where the error was thrown.
   assert.strictEqual(err.stack.split('\n')[1].indexOf('doSomethingBad'), 7);
-
   // The extra property should have been set
-  assert.strictEqual(err.extra, 42);
-}
-
-// Spoiler: It passes!
+  assert.strictEqual(err.statusCode, 400);
+}
diff --git a/custom-error.js b/custom-error.js
@@ -1,11 +1,10 @@
-module.exports = CustomError;
+'use strict';
 
-function CustomError(message, extra) {
-  Error.call(this);
+module.exports = function CustomError(message, extra) {
   Error.captureStackTrace(this, this.constructor);
   this.name = this.constructor.name;
   this.message = message;
   this.extra = extra;
-}
+};
 
-require('util').inherits(CustomError, Error);
+require('util').inherits(module.exports, Error);
diff --git a/error.md b/error.md
@@ -11,3 +11,17 @@ function doSomethingBad() {
   throw new CustomError('It went bad!', 42);
 }
 ```
+
+### Features
+
+* **Name appears once** - less editing if you have to create lots of custom error classes
+* **Easy to subclass** - just change the last line to inherit from another custom error class you created
+* **Correct stack trace** - no extra stack frames, no double capturing of the stack trace
+
+### Anti-patterns
+
+These are some things that I've seen in other proposed solutions that you should avoid.
+
+* `Error.call(this)` - creates another error object (wasting a bunch of time) and doesn't touch `this` at all
+* `Error.captureStackTrace(this, arguments.callee);` - works, but `arguments.callee` is deprecated, so don't use it
+* `this.stack = (new Error).stack` - this... I don't even...
diff --git a/error.md b/error.md
@@ -1,8 +1,8 @@
 It's nice to be able to distinguish error types by classes. But it's a bit tricky to correctly create a custom error class in Node.js, so here is an example.
 
-This example also shows how to add an extra parameter called `extra` that will be stored as a property on the error.
+The example also shows how to add an extra parameter called `extra` that will be stored as a property on the error.
 
-Example usage:
+### Usage
 
 ``` js
 var CustomError = require('./errors/custom-error');

diff --git a/error.md b/error.md
@@ -1,4 +1,4 @@
-Sometimes you want to wrap error objects with application-specific errors for your stack traces.
+It's nice to be able to distinguish error types by classes. But it's a bit tricky to correctly create a custom error class in Node.js, so here is an example.
 
 This example also shows how to add an extra parameter called `extra` that will be stored as a property on the error.
 

diff --git a/error.md b/error.md
@@ -7,7 +7,7 @@ Example usage:
 ``` js
 var CustomError = require('./errors/custom-error');
 
-function doSomethingRisky(callback) {
-  throw new CustomError('You lost!', 42);
+function doSomethingBad() {
+  throw new CustomError('It went bad!', 42);
 }
 ```
diff --git a/test-error.js b/test-error.js
@@ -0,0 +1,43 @@
+// Mini test suite for our custom error
+
+var assert = require('assert');
+var CustomError = require('./errors/custom-error');
+
+function doSomethingBad() {
+  throw new CustomError('It went bad!', 42);
+}
+
+try {
+  doSomethingBad();
+} catch (err) {
+  // The name property should be set to the error's name
+  assert(err.name = 'CustomError');
+
+  // The error should be an instance of its class
+  assert(err instanceof CustomError);
+
+  // The error should be an instance of builtin Error
+  assert(err instanceof Error);
+
+  // The error should be recognized by Node.js' util#isError
+  assert(require('util').isError(err));
+
+  // The error should have recorded a stack
+  assert(err.stack);
+
+  // toString should return the default error message formatting
+  assert.strictEqual(err.toString(),
+                     'CustomError: It went bad!');
+
+  // The stack should start with the default error message formatting
+  assert.strictEqual(err.stack.split('\n')[0],
+                     'CustomError: It went bad!');
+
+  // The first stack frame should be the function where the error was thrown.
+  assert.strictEqual(err.stack.split('\n')[1].indexOf('doSomethingBad'), 7);
+
+  // The extra property should have been set
+  assert.strictEqual(err.extra, 42);
+}
+
+// Spoiler: It passes!
diff --git a/custom-error.js b/custom-error.js
@@ -0,0 +1,11 @@
+module.exports = CustomError;
+
+function CustomError(message, extra) {
+  Error.call(this);
+  Error.captureStackTrace(this, this.constructor);
+  this.name = this.constructor.name;
+  this.message = message;
+  this.extra = extra;
+}
+
+require('util').inherits(CustomError, Error);
diff --git a/error.md b/error.md
@@ -1,26 +1,13 @@
 Sometimes you want to wrap error objects with application-specific errors for your stack traces.
 
-Your custom error constructor:
-
-```
-function CustomError(e, extra) {
-  Error.call(this);
-  Error.captureStackTrace(this, CustomError);
-  this.id = e.id;
-  this.name = 'CustomError';
-  this.message = e.message
-}
-
-require('util').inherits(CustomError, Error);
-```
+This example also shows how to add an extra parameter called `extra` that will be stored as a property on the error.
 
 Example usage:
 
-  function doWork(callback) {
-    doErrorProneWork(funtion(err, result) {
-      if (err) return callback(new CustomError(err));
-
-      ...
-    }
-  }
+``` js
+var CustomError = require('./errors/custom-error');
 
+function doSomethingRisky(callback) {
+  throw new CustomError('You lost!', 42);
+}
+```
diff --git a/error.md b/error.md
@@ -0,0 +1,26 @@
+Sometimes you want to wrap error objects with application-specific errors for your stack traces.
+
+Your custom error constructor:
+
+```
+function CustomError(e, extra) {
+  Error.call(this);
+  Error.captureStackTrace(this, CustomError);
+  this.id = e.id;
+  this.name = 'CustomError';
+  this.message = e.message
+}
+
+require('util').inherits(CustomError, Error);
+```
+
+Example usage:
+
+  function doWork(callback) {
+    doErrorProneWork(funtion(err, result) {
+      if (err) return callback(new CustomError(err));
+
+      ...
+    }
+  }
+
No results found