| Server IP : 68.65.120.201 / Your IP : 216.73.216.135 Web Server : LiteSpeed System : Linux server179.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64 User : taxhyuvu ( 2294) PHP Version : 8.1.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /home/taxhyuvu/nodevenv/public_html/dp_taxhelplines/10/lib/node_modules/@hapi/boom/lib/ |
Upload File : |
'use strict';
const Hoek = require('@hapi/hoek');
const internals = {
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, 'Too Early'],
[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.Boom = class extends Error {
constructor(message, options = {}) {
if (message instanceof Error) {
return exports.boomify(Hoek.clone(message), options);
}
const { statusCode = 500, data = null, ctor = exports.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;
const boom = internals.initialize(error, statusCode);
Object.defineProperty(boom, 'typeof', { value: ctor });
if (options.decorate) {
Object.assign(boom, options.decorate);
}
return boom;
}
static [Symbol.hasInstance](instance) {
if (this === exports.Boom) {
return exports.isBoom(instance);
}
// Cannot use 'instanceof' as it creates infinite recursion
return this.prototype.isPrototypeOf(instance);
}
};
exports.isBoom = function (err, statusCode) {
return err instanceof Error && !!err.isBoom && (!statusCode || err.output.statusCode === statusCode);
};
exports.boomify = function (err, options) {
Hoek.assert(err instanceof Error, 'Cannot wrap non-Error object');
options = options || {};
if (options.data !== undefined) {
err.data = options.data;
}
if (options.decorate) {
Object.assign(err, options.decorate);
}
if (!err.isBoom) {
return internals.initialize(err, options.statusCode || 500, options.message);
}
if (options.override === false || // Defaults to true
!options.statusCode && !options.message) {
return err;
}
return internals.initialize(err, options.statusCode || err.output.statusCode, options.message);
};
// 4xx Client Errors
exports.badRequest = function (message, data) {
return new exports.Boom(message, { statusCode: 400, data, ctor: exports.badRequest });
};
exports.unauthorized = function (message, scheme, attributes) { // Or (message, wwwAuthenticate[])
const err = new exports.Boom(message, { statusCode: 401, ctor: exports.unauthorized });
// function (message)
if (!scheme) {
return err;
}
// function (message, wwwAuthenticate[])
if (typeof scheme !== 'string') {
err.output.headers['WWW-Authenticate'] = scheme.join(', ');
return err;
}
// function (message, scheme, attributes)
let wwwAuthenticate = `${scheme}`;
if (attributes ||
message) {
err.output.payload.attributes = {};
}
if (attributes) {
if (typeof attributes === 'string') {
wwwAuthenticate += ' ' + Hoek.escapeHeaderAttribute(attributes);
err.output.payload.attributes = attributes;
}
else {
wwwAuthenticate += ' ' + Object.keys(attributes).map((name) => {
let value = attributes[name];
if (value === null ||
value === undefined) {
value = '';
}
err.output.payload.attributes[name] = value;
return `${name}="${Hoek.escapeHeaderAttribute(value.toString())}"`;
})
.join(', ');
}
}
if (message) {
if (attributes) {
wwwAuthenticate += ',';
}
wwwAuthenticate += ` error="${Hoek.escapeHeaderAttribute(message)}"`;
err.output.payload.attributes.error = message;
}
else {
err.isMissing = true;
}
err.output.headers['WWW-Authenticate'] = wwwAuthenticate;
return err;
};
exports.paymentRequired = function (message, data) {
return new exports.Boom(message, { statusCode: 402, data, ctor: exports.paymentRequired });
};
exports.forbidden = function (message, data) {
return new exports.Boom(message, { statusCode: 403, data, ctor: exports.forbidden });
};
exports.notFound = function (message, data) {
return new exports.Boom(message, { statusCode: 404, data, ctor: exports.notFound });
};
exports.methodNotAllowed = function (message, data, allow) {
const err = new exports.Boom(message, { statusCode: 405, data, ctor: exports.methodNotAllowed });
if (typeof allow === 'string') {
allow = [allow];
}
if (Array.isArray(allow)) {
err.output.headers.Allow = allow.join(', ');
}
return err;
};
exports.notAcceptable = function (message, data) {
return new exports.Boom(message, { statusCode: 406, data, ctor: exports.notAcceptable });
};
exports.proxyAuthRequired = function (message, data) {
return new exports.Boom(message, { statusCode: 407, data, ctor: exports.proxyAuthRequired });
};
exports.clientTimeout = function (message, data) {
return new exports.Boom(message, { statusCode: 408, data, ctor: exports.clientTimeout });
};
exports.conflict = function (message, data) {
return new exports.Boom(message, { statusCode: 409, data, ctor: exports.conflict });
};
exports.resourceGone = function (message, data) {
return new exports.Boom(message, { statusCode: 410, data, ctor: exports.resourceGone });
};
exports.lengthRequired = function (message, data) {
return new exports.Boom(message, { statusCode: 411, data, ctor: exports.lengthRequired });
};
exports.preconditionFailed = function (message, data) {
return new exports.Boom(message, { statusCode: 412, data, ctor: exports.preconditionFailed });
};
exports.entityTooLarge = function (message, data) {
return new exports.Boom(message, { statusCode: 413, data, ctor: exports.entityTooLarge });
};
exports.uriTooLong = function (message, data) {
return new exports.Boom(message, { statusCode: 414, data, ctor: exports.uriTooLong });
};
exports.unsupportedMediaType = function (message, data) {
return new exports.Boom(message, { statusCode: 415, data, ctor: exports.unsupportedMediaType });
};
exports.rangeNotSatisfiable = function (message, data) {
return new exports.Boom(message, { statusCode: 416, data, ctor: exports.rangeNotSatisfiable });
};
exports.expectationFailed = function (message, data) {
return new exports.Boom(message, { statusCode: 417, data, ctor: exports.expectationFailed });
};
exports.teapot = function (message, data) {
return new exports.Boom(message, { statusCode: 418, data, ctor: exports.teapot });
};
exports.badData = function (message, data) {
return new exports.Boom(message, { statusCode: 422, data, ctor: exports.badData });
};
exports.locked = function (message, data) {
return new exports.Boom(message, { statusCode: 423, data, ctor: exports.locked });
};
exports.failedDependency = function (message, data) {
return new exports.Boom(message, { statusCode: 424, data, ctor: exports.failedDependency });
};
exports.tooEarly = function (message, data) {
return new exports.Boom(message, { statusCode: 425, data, ctor: exports.tooEarly });
};
exports.preconditionRequired = function (message, data) {
return new exports.Boom(message, { statusCode: 428, data, ctor: exports.preconditionRequired });
};
exports.tooManyRequests = function (message, data) {
return new exports.Boom(message, { statusCode: 429, data, ctor: exports.tooManyRequests });
};
exports.illegal = function (message, data) {
return new exports.Boom(message, { statusCode: 451, data, ctor: exports.illegal });
};
// 5xx Server Errors
exports.internal = function (message, data, statusCode = 500) {
return internals.serverError(message, data, statusCode, exports.internal);
};
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;
};
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);
err.isBoom = true;
err.isServer = numberCode >= 500;
if (!err.hasOwnProperty('data')) {
err.data = null;
}
err.output = {
statusCode: numberCode,
payload: {},
headers: {}
};
Object.defineProperty(err, 'reformat', { value: internals.reformat, configurable: true });
if (!message &&
!err.message) {
err.reformat();
message = err.output.payload.error;
}
if (message) {
const props = Object.getOwnPropertyDescriptor(err, 'message') || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(err), 'message');
Hoek.assert(!props || props.configurable && !props.get, 'The error is not compatible with boom');
err.message = message + (err.message ? ': ' + err.message : '');
err.output.payload.message = err.message;
}
err.reformat();
return err;
};
internals.reformat = function (debug = false) {
this.output.payload.statusCode = this.output.statusCode;
this.output.payload.error = internals.codes.get(this.output.statusCode) || 'Unknown';
if (this.output.statusCode === 500 && debug !== true) {
this.output.payload.message = 'An internal server error occurred'; // Hide actual error from user
}
else if (this.message) {
this.output.payload.message = this.message;
}
};
internals.serverError = function (message, data, statusCode, ctor) {
if (data instanceof Error &&
!data.isBoom) {
return exports.boomify(data, { statusCode, message });
}
return new exports.Boom(message, { statusCode, data, ctor });
};