boom - npm Package Compare versions

Comparing version 0.2.1 to 0.3.0

lib/index.js

@@ -12,31 +12,47 @@ // Load modules
 
+/*
+    Boom(new Error)
+    Boom(code, message)
+*/
 
-exports = module.exports = internals.Error = function (code, message) {
+exports = module.exports = internals.Boom = function () {
 
     var self = this;
 
-    Hoek.assert(this.constructor === internals.Error, 'Error must be instantiated using new');
-    Hoek.assert(code instanceof Error || (!isNaN(parseFloat(code)) && isFinite(code) && code >= 400), 'code must be an Error or a number (400+)');
+    Hoek.assert(this.constructor === internals.Boom, 'Error must be instantiated using new');
 
     Error.call(this);
 
-    if (code instanceof Error) {
-        for (var d in code) {
-            if (code.hasOwnProperty(d)) {
-                this[d] = code[d];
-            }
-        }
+    this.response = {
+        code: 0,
+        payload: {},
+        headers: {}
+        // type: 'content-type'
+    };
 
-        this.code = this.code || 500;
-        this.name = code.name;
-        this.message = code.message || message;
-        if (code.message && message) {
-            this.info = message;
+    if (arguments[0] instanceof Error) {
+
+        // Error
+
+        var error = arguments[0];
+
+        this.data = error;
+        this.response.code = error.code || 500;
+        if (error.message) {
+            this.message = error.message
         }
-
-        this.toResponse = code.toResponse;          // Required if toRepsonse is a prototype function
     }
     else {
-        this.code = code;
-        this.message = message;
+
+        // code, message
+
+        var code = arguments[0];
+        var message = arguments[1];
+
+        Hoek.assert(!isNaN(parseFloat(code)) && isFinite(code) && code >= 400, 'First argument must be a number (400+)');
+
+        this.response.code = code;
+        if (message) {
+            this.message = message
+        }
     }
@@ -46,37 +62,17 @@
 
-    if (!this.toResponse ||
-        typeof this.toResponse !== 'function') {
+    this.reformat();
 
-        this.toResponse = internals.toResponse;
-    }
-
     return this;
 };
 
-NodeUtil.inherits(internals.Error, Error);
+NodeUtil.inherits(internals.Boom, Error);
 
 
-internals.toResponse = function () {
+internals.Boom.prototype.reformat = function () {
 
-    // { code, payload, type, headers }
-
-    var response = {
-        code: this.code,
-        payload: {
-            error: Http.STATUS_CODES[this.code] || 'Unknown',
-            code: this.code,
-            message: this.message
-        }
-    };
-
-    for (var d in this) {
-        if (['error', 'code', 'message'].indexOf(d) === -1 &&
-            this.hasOwnProperty(d) &&
-            typeof this[d] !== 'function') {
-
-            response.payload[d] = this[d];
-        }
+    this.response.payload.code = this.response.code;
+    this.response.payload.error = Http.STATUS_CODES[this.response.code] || 'Unknown';
+    if (this.message) {
+        this.response.payload.message = this.message;
     }
-
-    return response;
 };
@@ -87,11 +83,11 @@
 
-internals.Error.badRequest = function (message) {
+internals.Boom.badRequest = function (message) {
 
-    return new internals.Error(400, message);
+    return new internals.Boom(400, message);
 };
 
 
-internals.Error.unauthorized = function (error, scheme, attributes) {           // Or function (error, wwwAuthenticate[])
+internals.Boom.unauthorized = function (error, scheme, attributes) {           // Or function (error, wwwAuthenticate[])
 
-    var err = new internals.Error(401, error);
+    var err = new internals.Boom(401, error);
 
@@ -150,9 +146,4 @@ if (!scheme) {
 
-    err.toResponse = function () {
+    err.response.headers['WWW-Authenticate'] = wwwAuthenticate;
 
-        var response = internals.toResponse.call(this);
-        response.headers = { 'WWW-Authenticate': wwwAuthenticate };
-        return response;
-    };
-
     return err;
@@ -162,39 +153,33 @@ };
 
-internals.Error.clientTimeout = function (message) {
+internals.Boom.clientTimeout = function (message) {
 
-    return new internals.Error(408, message);
+    return new internals.Boom(408, message);
 };
 
 
-internals.Error.serverTimeout = function (message) {
+internals.Boom.serverTimeout = function (message) {
 
-    return new internals.Error(503, message);
+    return new internals.Boom(503, message);
 };
 
 
-internals.Error.forbidden = function (message) {
+internals.Boom.forbidden = function (message) {
 
-    return new internals.Error(403, message);
+    return new internals.Boom(403, message);
 };
 
 
-internals.Error.notFound = function (message) {
+internals.Boom.notFound = function (message) {
 
-    return new internals.Error(404, message);
+    return new internals.Boom(404, message);
 };
 
 
-internals.Error.internal = function (message, data) {
+internals.Boom.internal = function (message, data) {
 
-    var err = new internals.Error(500, message);
+    var err = new internals.Boom(500, message);
     err.trace = Hoek.displayStack(1);
     err.data = data;
+    err.response.payload.message = 'An internal server error occurred';                     // Hide actual error from user
 
-    err.toResponse = function () {
-
-        var response = internals.toResponse.call(this);
-        response.payload.message = 'An internal server error occurred';                 // Hide actual error from user
-        return response;
-    };
-
     return err;
@@ -204,7 +189,7 @@ };
 
-internals.Error.passThrough = function (code, payload, contentType, headers) {
+internals.Boom.passThrough = function (code, payload, contentType, headers) {
 
-    var err = new internals.Error(500, 'Pass-through');                     // 500 code is only used internally and is not exposed when sent
+    var err = new internals.Boom(500, 'Pass-through');                                      // 500 code is only used to initialize
 
-    err.passThrough = {
+    err.data = {
         code: code,
@@ -215,14 +200,7 @@ payload: payload,
 
-    err.toResponse = function () {
+    err.response.code = code;
+    err.response.type = contentType;
+    err.response.headers = headers;
+    err.response.payload = payload;
 
-        var response = {
-            code: code,
-            payload: payload,
-            type: contentType,
-            headers: headers
-        };
-
-        return response;
-    };
-
     return err;
@@ -229,0 +207,0 @@ };

package.json

 {
   "name": "boom",
   "description": "HTTP-friendly error objects",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "author": "Eran Hammer <[e-mail]> (http://hueniverse.com)",
@@ -6,0 +6,0 @@ "contributors": [],

test/index.js

@@ -19,20 +19,17 @@ // Load modules
 
-    it('returns an error with info when constructed using another error and message', function (done) {
+    it('returns an error with info when constructed using another error', function (done) {
 
-        var error = new Error('inner');
+        var error = new Error('ka-boom');
         error.xyz = 123;
-        var err = new Boom(error, 'outter');
-        expect(err.message).to.equal('inner');
-        expect(err.info).to.equal('outter');
-        expect(err.xyz).to.equal(123);
-        expect(err.toResponse()).to.deep.equal({
+        var err = new Boom(error);
+        expect(err.data.xyz).to.equal(123);
+        expect(err.message).to.equal('ka-boom');
+        expect(err.response).to.deep.equal({
             code: 500,
             payload: {
+                code: 500,
                 error: 'Internal Server Error',
-                code: 500,
-                message: 'inner',
-                xyz: 123,
-                name: 'Error',
-                info: 'outter'
-            }
+                message: 'ka-boom'
+            },
+            headers: {}
         });
@@ -46,3 +43,3 @@ done();
 
-            expect(Boom.badRequest().code).to.equal(400);
+            expect(Boom.badRequest().response.code).to.equal(400);
             done();
@@ -63,4 +60,4 @@ });
             var err = Boom.unauthorized();
-            expect(err.code).to.equal(401);
-            expect(err.toResponse().headers).to.not.exist;
+            expect(err.response.code).to.equal(401);
+            expect(err.response.headers).to.deep.equal({});
             done();
@@ -78,4 +75,4 @@ });
             var err = Boom.unauthorized('boom', 'Test');
-            expect(err.code).to.equal(401);
-            expect(err.toResponse().headers['WWW-Authenticate']).to.equal('Test error="boom"');
+            expect(err.response.code).to.equal(401);
+            expect(err.response.headers['WWW-Authenticate']).to.equal('Test error="boom"');
             done();
@@ -87,4 +84,4 @@ });
             var err = Boom.unauthorized('boom', 'Test', { a: 1, b: 'something', c: null, d: 0 });
-            expect(err.code).to.equal(401);
-            expect(err.toResponse().headers['WWW-Authenticate']).to.equal('Test a="1", b="something", c="", d="0", error="boom"');
+            expect(err.response.code).to.equal(401);
+            expect(err.response.headers['WWW-Authenticate']).to.equal('Test a="1", b="something", c="", d="0", error="boom"');
             done();
@@ -110,3 +107,3 @@ });
             var err = Boom.unauthorized('message', ['Basic', 'Example e="1"', 'Another x="3", y="4"']);
-            expect(err.toResponse().headers['WWW-Authenticate']).to.equal('Basic, Example e="1", Another x="3", y="4"');
+            expect(err.response.headers['WWW-Authenticate']).to.equal('Basic, Example e="1", Another x="3", y="4"');
             done();
@@ -120,3 +117,3 @@ });
 
-            expect(Boom.clientTimeout().code).to.equal(408);
+            expect(Boom.clientTimeout().response.code).to.equal(408);
             done();
@@ -136,3 +133,3 @@ });
 
-            expect(Boom.serverTimeout().code).to.equal(503);
+            expect(Boom.serverTimeout().response.code).to.equal(503);
             done();
@@ -152,3 +149,3 @@ });
 
-            expect(Boom.forbidden().code).to.equal(403);
+            expect(Boom.forbidden().response.code).to.equal(403);
             done();
@@ -168,3 +165,3 @@ });
 
-            expect(Boom.notFound().code).to.equal(404);
+            expect(Boom.notFound().response.code).to.equal(404);
             done();
@@ -184,3 +181,3 @@ });
 
-            expect(Boom.internal().code).to.equal(500);
+            expect(Boom.internal().response.code).to.equal(500);
             done();
@@ -193,3 +190,3 @@ });
             expect(err.message).to.equal('my message');
-            expect(err.toResponse().payload.message).to.equal('An internal server error occurred');
+            expect(err.response.payload.message).to.equal('An internal server error occurred');
             done();
@@ -210,9 +207,9 @@ });
             var err = Boom.passThrough(499, { a: 1 }, 'application/text', { 'X-Test': 'Boom' });
-            expect(err.code).to.equal(500);
+            expect(err.response.code).to.equal(499);
             expect(err.message).to.equal('Pass-through');
-            expect(err.toResponse()).to.deep.equal({
+            expect(err.response).to.deep.equal({
                 code: 499,
                 payload: { a: 1 },
-                type: 'application/text',
-                headers: { 'X-Test': 'Boom' }
+                headers: { 'X-Test': 'Boom' },
+                type: 'application/text'
             });
@@ -219,0 +216,0 @@ done();

No alert changes

Worsened metrics

Total package byte prevSize

14355

decreased by-5.03%

Lines of code

278

decreased by-7.02%

No dependency changes