boom - npm Package Compare versions

Comparing version 6.0.0 to 7.1.1

lib/index.js

@@ -11,402 +11,411 @@ 'use strict';
 const internals = {
-    STATUS_CODES: Object.setPrototypeOf({
-        '100': 'Continue',
-        '101': 'Switching Protocols',
-        '102': 'Processing',
-        '200': 'OK',
-        '201': 'Created',
-        '202': 'Accepted',
-        '203': 'Non-Authoritative Information',
-        '204': 'No Content',
-        '205': 'Reset Content',
-        '206': 'Partial Content',
-        '207': 'Multi-Status',
-        '300': 'Multiple Choices',
-        '301': 'Moved Permanently',
-        '302': 'Moved Temporarily',
-        '303': 'See Other',
-        '304': 'Not Modified',
-        '305': 'Use Proxy',
-        '307': 'Temporary Redirect',
-        '400': 'Bad Request',
-        '401': 'Unauthorized',
-        '402': 'Payment Required',
-        '403': 'Forbidden',
-        '404': 'Not Found',
-        '405': 'Method Not Allowed',
-        '406': 'Not Acceptable',
-        '407': 'Proxy Authentication Required',
-        '408': 'Request Time-out',
-        '409': 'Conflict',
-        '410': 'Gone',
-        '411': 'Length Required',
-        '412': 'Precondition Failed',
-        '413': 'Request Entity Too Large',
-        '414': 'Request-URI Too Large',
-        '415': 'Unsupported Media Type',
-        '416': 'Requested Range Not Satisfiable',
-        '417': 'Expectation Failed',
-        '418': 'I\'m a teapot',
-        '422': 'Unprocessable Entity',
-        '423': 'Locked',
-        '424': 'Failed Dependency',
-        '425': 'Unordered Collection',
-        '426': 'Upgrade Required',
-        '428': 'Precondition Required',
-        '429': 'Too Many Requests',
-        '431': 'Request Header Fields Too Large',
-        '451': 'Unavailable For Legal Reasons',
-        '500': 'Internal Server Error',
-        '501': 'Not Implemented',
-        '502': 'Bad Gateway',
-        '503': 'Service Unavailable',
-        '504': 'Gateway Time-out',
-        '505': 'HTTP Version Not Supported',
-        '506': 'Variant Also Negotiates',
-        '507': 'Insufficient Storage',
-        '509': 'Bandwidth Limit Exceeded',
-        '510': 'Not Extended',
-        '511': 'Network Authentication Required'
-    }, null)
+    codes: new Map([
+        [100, 'Continue'],
+        [101, 'Switching Protocols'],
+        [102, 'Processing'],
+        [200, 'OK'],
+        [201, 'Created'],
+        [202, 'Accepted'],
+        [203, 'Non-Authoritative Information'],
+        [204, 'No Content'],
+        [205, 'Reset Content'],
+        [206, 'Partial Content'],
+        [207, 'Multi-Status'],
+        [300, 'Multiple Choices'],
+        [301, 'Moved Permanently'],
+        [302, 'Moved Temporarily'],
+        [303, 'See Other'],
+        [304, 'Not Modified'],
+        [305, 'Use Proxy'],
+        [307, 'Temporary Redirect'],
+        [400, 'Bad Request'],
+        [401, 'Unauthorized'],
+        [402, 'Payment Required'],
+        [403, 'Forbidden'],
+        [404, 'Not Found'],
+        [405, 'Method Not Allowed'],
+        [406, 'Not Acceptable'],
+        [407, 'Proxy Authentication Required'],
+        [408, 'Request Time-out'],
+        [409, 'Conflict'],
+        [410, 'Gone'],
+        [411, 'Length Required'],
+        [412, 'Precondition Failed'],
+        [413, 'Request Entity Too Large'],
+        [414, 'Request-URI Too Large'],
+        [415, 'Unsupported Media Type'],
+        [416, 'Requested Range Not Satisfiable'],
+        [417, 'Expectation Failed'],
+        [418, 'I\'m a teapot'],
+        [422, 'Unprocessable Entity'],
+        [423, 'Locked'],
+        [424, 'Failed Dependency'],
+        [425, 'Unordered Collection'],
+        [426, 'Upgrade Required'],
+        [428, 'Precondition Required'],
+        [429, 'Too Many Requests'],
+        [431, 'Request Header Fields Too Large'],
+        [451, 'Unavailable For Legal Reasons'],
+        [500, 'Internal Server Error'],
+        [501, 'Not Implemented'],
+        [502, 'Bad Gateway'],
+        [503, 'Service Unavailable'],
+        [504, 'Gateway Time-out'],
+        [505, 'HTTP Version Not Supported'],
+        [506, 'Variant Also Negotiates'],
+        [507, 'Insufficient Storage'],
+        [509, 'Bandwidth Limit Exceeded'],
+        [510, 'Not Extended'],
+        [511, 'Network Authentication Required']
+    ])
 };
 
 
-exports.boomify = function (error, options) {
+module.exports = internals.Boom = class extends Error {
 
-    Hoek.assert(error instanceof Error, 'Cannot wrap non-Error object');
+    static [Symbol.hasInstance](instance) {
 
-    options = options || {};
-
-    if (!error.isBoom) {
-        return internals.initialize(error, options.statusCode || 500, options.message);
+        return internals.Boom.isBoom(instance);
     }
 
-    if (options.override === false ||                           // Defaults to true
-        (!options.statusCode && !options.message)) {
+    constructor(message, options = {}) {
 
-        return error;
-    }
+        if (message instanceof Error) {
+            return internals.Boom.boomify(Hoek.clone(message), options);
+        }
 
-    return internals.initialize(error, options.statusCode || error.output.statusCode, options.message);
-};
+        const { statusCode = 500, data = null, ctor = internals.Boom } = options;
+        const error = new Error(message ? message : undefined);         // Avoids settings null message
+        Error.captureStackTrace(error, ctor);                           // Filter the stack to our external API
+        error.data = data;
+        internals.initialize(error, statusCode);
+        error.typeof = ctor;
 
-
-exports.wrap = function (error, statusCode, message) {
-
-    Hoek.assert(error instanceof Error, 'Cannot wrap non-Error object');
-    Hoek.assert(!error.isBoom || (!statusCode && !message), 'Cannot provide statusCode or message with boom error');
-
-    return (error.isBoom ? error : internals.initialize(error, statusCode || 500, message));
-};
-
-
-exports.create = function (statusCode, message, data) {
-
-    return internals.create(statusCode, message, data, exports.create);
-};
-
-
-internals.create = function (statusCode, message, data, ctor) {
-
-    if (message instanceof Error) {
-        if (data) {
-            message.data = data;
+        if (options.decorate) {
+            Object.assign(error, options.decorate);
         }
 
-        return exports.wrap(message, statusCode);
+        return error;
     }
 
-    const error = new Error(message ? message : undefined);         // Avoids settings null message
-    Error.captureStackTrace(error, ctor);                           // Filter the stack to our external API
-    error.data = data || null;
-    internals.initialize(error, statusCode);
-    error.typeof = ctor;
+    static isBoom(err) {
 
-    return error;
-};
+        return (err instanceof Error && !!err.isBoom);
+    }
 
+    static boomify(err, options) {
 
-internals.initialize = function (error, statusCode, message) {
+        Hoek.assert(err instanceof Error, 'Cannot wrap non-Error object');
 
-    const numberCode = parseInt(statusCode, 10);
-    Hoek.assert(!isNaN(numberCode) && numberCode >= 400, 'First argument must be a number (400+):', statusCode);
+        options = options || {};
 
-    error.isBoom = true;
-    error.isServer = numberCode >= 500;
+        if (options.data !== undefined) {
+            err.data = options.data;
+        }
 
-    if (!error.hasOwnProperty('data')) {
-        error.data = null;
-    }
+        if (options.decorate) {
+            Object.assign(err, options.decorate);
+        }
 
-    error.output = {
-        statusCode: numberCode,
-        payload: {},
-        headers: {}
-    };
+        if (!err.isBoom) {
+            return internals.initialize(err, options.statusCode || 500, options.message);
+        }
 
-    error.reformat = internals.reformat;
+        if (options.override === false ||                           // Defaults to true
+            (!options.statusCode && !options.message)) {
 
-    if (!message &&
-        !error.message) {
+            return err;
+        }
 
-        error.reformat();
-        message = error.output.payload.error;
+        return internals.initialize(err, options.statusCode || err.output.statusCode, options.message);
     }
 
-    if (message) {
-        error.message = (message + (error.message ? ': ' + error.message : ''));
-        error.output.payload.message = error.message;
-    }
+    // 4xx Client Errors
 
-    error.reformat();
-    return error;
-};
+    static badRequest(message, data) {
 
-
-internals.reformat = function () {
-
-    this.output.payload.statusCode = this.output.statusCode;
-    this.output.payload.error = internals.STATUS_CODES[this.output.statusCode] || 'Unknown';
-
-    if (this.output.statusCode === 500) {
-        this.output.payload.message = 'An internal server error occurred';              // Hide actual error from user
+        return new internals.Boom(message, { statusCode: 400, data, ctor: internals.Boom.badRequest });
     }
-    else if (this.message) {
-        this.output.payload.message = this.message;
-    }
-};
 
+    static unauthorized(message, scheme, attributes) {          // Or function (message, wwwAuthenticate[])
 
-// 4xx Client Errors
+        const err = new internals.Boom(message, { statusCode: 401, ctor: internals.Boom.unauthorized });
 
-exports.badRequest = function (message, data) {
+        if (!scheme) {
+            return err;
+        }
 
-    return internals.create(400, message, data, exports.badRequest);
-};
+        let wwwAuthenticate = '';
 
+        if (typeof scheme === 'string') {
 
-exports.unauthorized = function (message, scheme, attributes) {          // Or function (message, wwwAuthenticate[])
+            // function (message, scheme, attributes)
 
-    const err = internals.create(401, message, undefined, exports.unauthorized);
+            wwwAuthenticate = scheme;
 
-    if (!scheme) {
-        return err;
-    }
+            if (attributes || message) {
+                err.output.payload.attributes = {};
+            }
 
-    let wwwAuthenticate = '';
+            if (attributes) {
+                if (typeof attributes === 'string') {
+                    wwwAuthenticate = wwwAuthenticate + ' ' + Hoek.escapeHeaderAttribute(attributes);
+                    err.output.payload.attributes = attributes;
+                }
+                else {
+                    const names = Object.keys(attributes);
+                    for (let i = 0; i < names.length; ++i) {
+                        const name = names[i];
+                        if (i) {
+                            wwwAuthenticate = wwwAuthenticate + ',';
+                        }
 
-    if (typeof scheme === 'string') {
+                        let value = attributes[name];
+                        if (value === null ||
+                            value === undefined) {              // Value can be zero
 
-        // function (message, scheme, attributes)
+                            value = '';
+                        }
+                        wwwAuthenticate = wwwAuthenticate + ' ' + name + '="' + Hoek.escapeHeaderAttribute(value.toString()) + '"';
+                        err.output.payload.attributes[name] = value;
+                    }
+                }
+            }
 
-        wwwAuthenticate = scheme;
 
-        if (attributes || message) {
-            err.output.payload.attributes = {};
-        }
-
-        if (attributes) {
-            if (typeof attributes === 'string') {
-                wwwAuthenticate = wwwAuthenticate + ' ' + Hoek.escapeHeaderAttribute(attributes);
-                err.output.payload.attributes = attributes;
+            if (message) {
+                if (attributes) {
+                    wwwAuthenticate = wwwAuthenticate + ',';
+                }
+                wwwAuthenticate = wwwAuthenticate + ' error="' + Hoek.escapeHeaderAttribute(message) + '"';
+                err.output.payload.attributes.error = message;
             }
             else {
-                const names = Object.keys(attributes);
-                for (let i = 0; i < names.length; ++i) {
-                    const name = names[i];
-                    if (i) {
-                        wwwAuthenticate = wwwAuthenticate + ',';
-                    }
+                err.isMissing = true;
+            }
+        }
+        else {
 
-                    let value = attributes[name];
-                    if (value === null ||
-                        value === undefined) {              // Value can be zero
+            // function (message, wwwAuthenticate[])
 
-                        value = '';
-                    }
-                    wwwAuthenticate = wwwAuthenticate + ' ' + name + '="' + Hoek.escapeHeaderAttribute(value.toString()) + '"';
-                    err.output.payload.attributes[name] = value;
+            const wwwArray = scheme;
+            for (let i = 0; i < wwwArray.length; ++i) {
+                if (i) {
+                    wwwAuthenticate = wwwAuthenticate + ', ';
                 }
+
+                wwwAuthenticate = wwwAuthenticate + wwwArray[i];
             }
         }
 
+        err.output.headers['WWW-Authenticate'] = wwwAuthenticate;
 
-        if (message) {
-            if (attributes) {
-                wwwAuthenticate = wwwAuthenticate + ',';
-            }
-            wwwAuthenticate = wwwAuthenticate + ' error="' + Hoek.escapeHeaderAttribute(message) + '"';
-            err.output.payload.attributes.error = message;
-        }
-        else {
-            err.isMissing = true;
-        }
+        return err;
     }
-    else {
 
-        // function (message, wwwAuthenticate[])
+    static paymentRequired(message, data) {
 
-        const wwwArray = scheme;
-        for (let i = 0; i < wwwArray.length; ++i) {
-            if (i) {
-                wwwAuthenticate = wwwAuthenticate + ', ';
-            }
-
-            wwwAuthenticate = wwwAuthenticate + wwwArray[i];
-        }
+        return new internals.Boom(message, { statusCode: 402, data, ctor: internals.Boom.paymentRequired });
     }
 
-    err.output.headers['WWW-Authenticate'] = wwwAuthenticate;
+    static forbidden(message, data) {
 
-    return err;
-};
+        return new internals.Boom(message, { statusCode: 403, data, ctor: internals.Boom.forbidden });
+    }
 
+    static notFound(message, data) {
 
-exports.paymentRequired = function (message, data) {
+        return new internals.Boom(message, { statusCode: 404, data, ctor: internals.Boom.notFound });
+    }
 
-    return internals.create(402, message, data, exports.paymentRequired);
-};
+    static methodNotAllowed(message, data, allow) {
 
+        const err = new internals.Boom(message, { statusCode: 405, data, ctor: internals.Boom.methodNotAllowed });
 
-exports.forbidden = function (message, data) {
+        if (typeof allow === 'string') {
+            allow = [allow];
+        }
 
-    return internals.create(403, message, data, exports.forbidden);
-};
+        if (Array.isArray(allow)) {
+            err.output.headers.Allow = allow.join(', ');
+        }
 
+        return err;
+    }
 
-exports.notFound = function (message, data) {
+    static notAcceptable(message, data) {
 
-    return internals.create(404, message, data, exports.notFound);
-};
+        return new internals.Boom(message, { statusCode: 406, data, ctor: internals.Boom.notAcceptable });
+    }
 
+    static proxyAuthRequired(message, data) {
 
-exports.methodNotAllowed = function (message, data, allow) {
+        return new internals.Boom(message, { statusCode: 407, data, ctor: internals.Boom.proxyAuthRequired });
+    }
 
-    const err = internals.create(405, message, data, exports.methodNotAllowed);
+    static clientTimeout(message, data) {
 
-    if (typeof allow === 'string') {
-        allow = [allow];
+        return new internals.Boom(message, { statusCode: 408, data, ctor: internals.Boom.clientTimeout });
     }
 
-    if (Array.isArray(allow)) {
-        err.output.headers.Allow = allow.join(', ');
+    static conflict(message, data) {
+
+        return new internals.Boom(message, { statusCode: 409, data, ctor: internals.Boom.conflict });
     }
 
-    return err;
-};
+    static resourceGone(message, data) {
 
+        return new internals.Boom(message, { statusCode: 410, data, ctor: internals.Boom.resourceGone });
+    }
 
-exports.notAcceptable = function (message, data) {
+    static lengthRequired(message, data) {
 
-    return internals.create(406, message, data, exports.notAcceptable);
-};
+        return new internals.Boom(message, { statusCode: 411, data, ctor: internals.Boom.lengthRequired });
+    }
 
+    static preconditionFailed(message, data) {
 
-exports.proxyAuthRequired = function (message, data) {
+        return new internals.Boom(message, { statusCode: 412, data, ctor: internals.Boom.preconditionFailed });
+    }
 
-    return internals.create(407, message, data, exports.proxyAuthRequired);
-};
+    static entityTooLarge(message, data) {
 
+        return new internals.Boom(message, { statusCode: 413, data, ctor: internals.Boom.entityTooLarge });
+    }
 
-exports.clientTimeout = function (message, data) {
+    static uriTooLong(message, data) {
 
-    return internals.create(408, message, data, exports.clientTimeout);
-};
+        return new internals.Boom(message, { statusCode: 414, data, ctor: internals.Boom.uriTooLong });
+    }
 
+    static unsupportedMediaType(message, data) {
 
-exports.conflict = function (message, data) {
+        return new internals.Boom(message, { statusCode: 415, data, ctor: internals.Boom.unsupportedMediaType });
+    }
 
-    return internals.create(409, message, data, exports.conflict);
-};
+    static rangeNotSatisfiable(message, data) {
 
+        return new internals.Boom(message, { statusCode: 416, data, ctor: internals.Boom.rangeNotSatisfiable });
+    }
 
-exports.resourceGone = function (message, data) {
+    static expectationFailed(message, data) {
 
-    return internals.create(410, message, data, exports.resourceGone);
-};
+        return new internals.Boom(message, { statusCode: 417, data, ctor: internals.Boom.expectationFailed });
+    }
 
+    static teapot(message, data) {
 
-exports.lengthRequired = function (message, data) {
+        return new internals.Boom(message, { statusCode: 418, data, ctor: internals.Boom.teapot });
+    }
 
-    return internals.create(411, message, data, exports.lengthRequired);
-};
+    static badData(message, data) {
 
+        return new internals.Boom(message, { statusCode: 422, data, ctor: internals.Boom.badData });
+    }
 
-exports.preconditionFailed = function (message, data) {
+    static locked(message, data) {
 
-    return internals.create(412, message, data, exports.preconditionFailed);
-};
+        return new internals.Boom(message, { statusCode: 423, data, ctor: internals.Boom.locked });
+    }
 
+    static preconditionRequired(message, data) {
 
-exports.entityTooLarge = function (message, data) {
+        return new internals.Boom(message, { statusCode: 428, data, ctor: internals.Boom.preconditionRequired });
+    }
 
-    return internals.create(413, message, data, exports.entityTooLarge);
-};
+    static tooManyRequests(message, data) {
 
+        return new internals.Boom(message, { statusCode: 429, data, ctor: internals.Boom.tooManyRequests });
+    }
 
-exports.uriTooLong = function (message, data) {
+    static illegal(message, data) {
 
-    return internals.create(414, message, data, exports.uriTooLong);
-};
+        return new internals.Boom(message, { statusCode: 451, data, ctor: internals.Boom.illegal });
+    }
 
+    // 5xx Server Errors
 
-exports.unsupportedMediaType = function (message, data) {
+    static internal(message, data, statusCode = 500) {
 
-    return internals.create(415, message, data, exports.unsupportedMediaType);
-};
+        return internals.serverError(message, data, statusCode, internals.Boom.internal);
+    }
 
+    static notImplemented(message, data) {
 
-exports.rangeNotSatisfiable = function (message, data) {
+        return internals.serverError(message, data, 501, internals.Boom.notImplemented);
+    }
 
-    return internals.create(416, message, data, exports.rangeNotSatisfiable);
-};
+    static badGateway(message, data) {
 
+        return internals.serverError(message, data, 502, internals.Boom.badGateway);
+    }
 
-exports.expectationFailed = function (message, data) {
+    static serverUnavailable(message, data) {
 
-    return internals.create(417, message, data, exports.expectationFailed);
-};
+        return internals.serverError(message, data, 503, internals.Boom.serverUnavailable);
+    }
 
+    static gatewayTimeout(message, data) {
 
-exports.teapot = function (message, data) {
+        return internals.serverError(message, data, 504, internals.Boom.gatewayTimeout);
+    }
 
-    return internals.create(418, message, data, exports.teapot);
-};
+    static badImplementation(message, data) {
 
-
-exports.badData = function (message, data) {
-
-    return internals.create(422, message, data, exports.badData);
+        const err = internals.serverError(message, data, 500, internals.Boom.badImplementation);
+        err.isDeveloperError = true;
+        return err;
+    }
 };
 
 
-exports.locked = function (message, data) {
 
-    return internals.create(423, message, data, exports.locked);
-};
+internals.initialize = function (err, statusCode, message) {
 
+    const numberCode = parseInt(statusCode, 10);
+    Hoek.assert(!isNaN(numberCode) && numberCode >= 400, 'First argument must be a number (400+):', statusCode);
 
-exports.preconditionRequired = function (message, data) {
+    err.isBoom = true;
+    err.isServer = numberCode >= 500;
 
-    return internals.create(428, message, data, exports.preconditionRequired);
-};
+    if (!err.hasOwnProperty('data')) {
+        err.data = null;
+    }
 
+    err.output = {
+        statusCode: numberCode,
+        payload: {},
+        headers: {}
+    };
 
-exports.tooManyRequests = function (message, data) {
+    err.reformat = internals.reformat;
 
-    return internals.create(429, message, data, exports.tooManyRequests);
-};
+    if (!message &&
+        !err.message) {
 
+        err.reformat();
+        message = err.output.payload.error;
+    }
 
-exports.illegal = function (message, data) {
+    if (message) {
+        err.message = (message + (err.message ? ': ' + err.message : ''));
+        err.output.payload.message = err.message;
+    }
 
-    return internals.create(451, message, data, exports.illegal);
+    err.reformat();
+    return err;
 };
 
 
-// 5xx Server Errors
+internals.reformat = function () {
 
-exports.internal = function (message, data, statusCode) {
+    this.output.payload.statusCode = this.output.statusCode;
+    this.output.payload.error = internals.codes.get(this.output.statusCode) || 'Unknown';
 
-    return internals.serverError(message, data, statusCode, exports.internal);
+    if (this.output.statusCode === 500) {
+        this.output.payload.message = 'An internal server error occurred';              // Hide actual error from user
+    }
+    else if (this.message) {
+        this.output.payload.message = this.message;
+    }
 };
@@ -420,40 +429,6 @@
 
-        return exports.wrap(data, statusCode, message);
+        return internals.Boom.boomify(data, { statusCode, message });
     }
 
-    const error = internals.create(statusCode || 500, message, undefined, ctor);
-    error.data = data;
-    return error;
+    return new internals.Boom(message, { statusCode, data, ctor });
 };
-
-
-exports.notImplemented = function (message, data) {
-
-    return internals.serverError(message, data, 501, exports.notImplemented);
-};
-
-
-exports.badGateway = function (message, data) {
-
-    return internals.serverError(message, data, 502, exports.badGateway);
-};
-
-
-exports.serverUnavailable = function (message, data) {
-
-    return internals.serverError(message, data, 503, exports.serverUnavailable);
-};
-
-
-exports.gatewayTimeout = function (message, data) {
-
-    return internals.serverError(message, data, 504, exports.gatewayTimeout);
-};
-
-
-exports.badImplementation = function (message, data) {
-
-    const err = internals.serverError(message, data, 500, exports.badImplementation);
-    err.isDeveloperError = true;
-    return err;
-};

package.json

 {
   "name": "boom",
   "description": "HTTP-friendly error objects",
-  "version": "6.0.0",
+  "version": "7.1.1",
   "repository": "git://github.com/hapijs/boom",
@@ -12,3 +12,3 @@ "main": "lib/index.js",
   "engines": {
-    "node": ">=8.0.0"
+    "node": ">=8.9.0"
   },
@@ -20,3 +20,3 @@ "dependencies": {
     "code": "5.x.x",
-    "lab": "14.x.x",
+    "lab": "15.x.x",
     "markdown-toc": "0.12.x"
@@ -23,0 +23,0 @@ },

README.md

@@ -14,5 +14,5 @@ ![boom Logo](https://raw.github.com/hapijs/boom/master/images/boom.png)
   - [Helper Methods](#helper-methods)
-    - [`boomify(error, [options])`](#boomifyerror-options)
-    - [`wrap(error, [statusCode], [message])`](#wraperror-statuscode-message)
-    - [`create(statusCode, [message], [data])`](#createstatuscode-message-data)
+    - [`new Boom(message, [options])`](#new-boommessage-options)
+    - [`boomify(err, [options])`](#boomifyerr-options)
+    - [`isBoom(err)`](#isboomerr)
   - [HTTP 4xx Errors](#http-4xx-errors)
@@ -55,8 +55,10 @@ - [`Boom.badRequest([message], [data])`](#boombadrequestmessage-data)
 
-**boom** provides a set of utilities for returning HTTP errors. Each utility returns a `Boom` error response
-object (instance of `Error`) which includes the following properties:
-- `isBoom` - if `true`, indicates this is a `Boom` object instance.
+**boom** provides a set of utilities for returning HTTP errors. Each utility returns a `Boom`
+error response object which includes the following properties:
+- `isBoom` - if `true`, indicates this is a `Boom` object instance. Note that this boolean should
+  only be used the the error is an instance of `Error`. If it is not certain, use `Boom.isBoom()`
+  instead.
 - `isServer` - convenience bool indicating status code >= 500.
 - `message` - the error message.
-- `typeof` - the contructor used to create the error (e.g. `Boom.badRequest`).
+- `typeof` - the constructor used to create the error (e.g. `Boom.badRequest`).
 - `output` - the formatted response. Can be directly manipulated after object construction to return a custom
@@ -77,8 +79,28 @@ error response. Allowed root keys:
 
+Note that `Boom` object will return `true` when used with `instanceof Boom`, but do not use the
+`Boom` prototype (they are either plain `Error` or the error prototype passed in). This means
+`Boom` objects should only be tested using `instaceof Boom` or `Boom.isBoom()` but not by looking
+at the prototype or contructor information. This limitation is to avoid manipulating the prototype
+chain which is very slow.
+
 ## Helper Methods
 
-### `boomify(error, [options])`
+### `new Boom(message, [options])`
 
-Decorates an error with the **boom** properties where:
-- `error` - the `Error` object to decorate.
+Creates a new `Boom` object using the provided `message` and then calling
+[`boomify()`](#boomifyerr-options) to decorate the error with the `Boom` properties, where:
+- `message` - the error message. If `message` is an error, it is the same as calling
+  [`boomify()`](#boomifyerr-options) directly.
+- `options` - and optional object where:
+	- `statusCode` - the HTTP status code. Defaults to `500` if no status code is already set.
+    - `data` - additional error information (assigned to `error.data`).
+    - `decorate` - an option with extra properties to set on the error object.
+    - `cotr` - constructor reference used to crop the exception call stack output.
+    - if `message` is an error object, also supports the other [`boomify()`](#boomifyerr-options)
+      options.
+
+### `boomify(err, [options])`
+
+Decorates an error with the `Boom` properties where:
+- `err` - the `Error` object to decorate.
 - `options` - optional object with the following optional settings:
@@ -88,9 +110,7 @@ - `statusCode` - the HTTP status code. Defaults to `500` if no status code is already set.
 	  Defaults to no message.
-	- `override` - if `false`, the `error` provided is a **boom** object, and a `statusCode` or `message` are provided,
+    - `decorate` - an option with extra properties to set on the error object.
+	- `override` - if `false`, the `err` provided is a `Boom` object, and a `statusCode` or `message` are provided,
 	  the values are ignored. Defaults to `true` (apply the provided `statusCode` and `message` options to the error
-	  regardless of its type, `Error` or **boom** object).
+	  regardless of its type, `Error` or `Boom` object).
 
-Note: This method replaces the [`wrap()`](#wraperror-statuscode-message) and changes the default behavior to override
-existing **boom** objects with the provided status code and message.
-
 ```js
@@ -101,28 +121,6 @@ var error = new Error('Unexpected input');
 
-### `wrap(error, [statusCode], [message])`
+### `isBoom(err)`
 
-Note: This method is deprecated.
+Identifies whether an error is a `Boom` object. Same as calling `instanceof Boom`.
 
-Decorates an error with the **boom** properties where:
-- `error` - the error object to wrap. If `error` is already a **boom** object, returns back the same object.
-- `statusCode` - optional HTTP status code. Defaults to `500`.
-- `message` - optional message string. If the error already has a message, it adds the message as a prefix.
-  Defaults to no message.
-
-```js
-var error = new Error('Unexpected input');
-Boom.wrap(error, 400);
-```
-
-### `create(statusCode, [message], [data])`
-
-Generates an `Error` object with the **boom** decorations where:
-- `statusCode` - an HTTP error code number. Must be greater or equal 400.
-- `message` - optional message string.
-- `data` - additional error data set to `error.data` property.
-
-```js
-var error = Boom.create(400, 'Bad request', { timestamp: Date.now() });
-```
-
 ## HTTP 4xx Errors
@@ -164,3 +162,4 @@
 
-If either `scheme` or `attributes` are set, the resultant `Boom` object will have the 'WWW-Authenticate' header set for the response.
+If either `scheme` or `attributes` are set, the resultant `Boom` object will have the
+'WWW-Authenticate' header set for the response.
 
@@ -167,0 +166,0 @@ ```js

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

35771

increased by3.9%

Lines of code

305

increased by1.67%

Worsened metrics

Number of lines in readme file

784

decreased by-0.13%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes