source: trip-planner-front/node_modules/http-errors/index.js@ 1ad8e64

Last change on this file since 1ad8e64 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 5.7 KB
Line 
1/*!
2 * http-errors
3 * Copyright(c) 2014 Jonathan Ong
4 * Copyright(c) 2016 Douglas Christopher Wilson
5 * MIT Licensed
6 */
7
8'use strict'
9
10/**
11 * Module dependencies.
12 * @private
13 */
14
15var deprecate = require('depd')('http-errors')
16var setPrototypeOf = require('setprototypeof')
17var statuses = require('statuses')
18var inherits = require('inherits')
19var toIdentifier = require('toidentifier')
20
21/**
22 * Module exports.
23 * @public
24 */
25
26module.exports = createError
27module.exports.HttpError = createHttpErrorConstructor()
28
29// Populate exports for all constructors
30populateConstructorExports(module.exports, statuses.codes, module.exports.HttpError)
31
32/**
33 * Get the code class of a status code.
34 * @private
35 */
36
37function codeClass (status) {
38 return Number(String(status).charAt(0) + '00')
39}
40
41/**
42 * Create a new HTTP Error.
43 *
44 * @returns {Error}
45 * @public
46 */
47
48function createError () {
49 // so much arity going on ~_~
50 var err
51 var msg
52 var status = 500
53 var props = {}
54 for (var i = 0; i < arguments.length; i++) {
55 var arg = arguments[i]
56 if (arg instanceof Error) {
57 err = arg
58 status = err.status || err.statusCode || status
59 continue
60 }
61 switch (typeof arg) {
62 case 'string':
63 msg = arg
64 break
65 case 'number':
66 status = arg
67 if (i !== 0) {
68 deprecate('non-first-argument status code; replace with createError(' + arg + ', ...)')
69 }
70 break
71 case 'object':
72 props = arg
73 break
74 }
75 }
76
77 if (typeof status === 'number' && (status < 400 || status >= 600)) {
78 deprecate('non-error status code; use only 4xx or 5xx status codes')
79 }
80
81 if (typeof status !== 'number' ||
82 (!statuses[status] && (status < 400 || status >= 600))) {
83 status = 500
84 }
85
86 // constructor
87 var HttpError = createError[status] || createError[codeClass(status)]
88
89 if (!err) {
90 // create error
91 err = HttpError
92 ? new HttpError(msg)
93 : new Error(msg || statuses[status])
94 Error.captureStackTrace(err, createError)
95 }
96
97 if (!HttpError || !(err instanceof HttpError) || err.status !== status) {
98 // add properties to generic error
99 err.expose = status < 500
100 err.status = err.statusCode = status
101 }
102
103 for (var key in props) {
104 if (key !== 'status' && key !== 'statusCode') {
105 err[key] = props[key]
106 }
107 }
108
109 return err
110}
111
112/**
113 * Create HTTP error abstract base class.
114 * @private
115 */
116
117function createHttpErrorConstructor () {
118 function HttpError () {
119 throw new TypeError('cannot construct abstract class')
120 }
121
122 inherits(HttpError, Error)
123
124 return HttpError
125}
126
127/**
128 * Create a constructor for a client error.
129 * @private
130 */
131
132function createClientErrorConstructor (HttpError, name, code) {
133 var className = name.match(/Error$/) ? name : name + 'Error'
134
135 function ClientError (message) {
136 // create the error object
137 var msg = message != null ? message : statuses[code]
138 var err = new Error(msg)
139
140 // capture a stack trace to the construction point
141 Error.captureStackTrace(err, ClientError)
142
143 // adjust the [[Prototype]]
144 setPrototypeOf(err, ClientError.prototype)
145
146 // redefine the error message
147 Object.defineProperty(err, 'message', {
148 enumerable: true,
149 configurable: true,
150 value: msg,
151 writable: true
152 })
153
154 // redefine the error name
155 Object.defineProperty(err, 'name', {
156 enumerable: false,
157 configurable: true,
158 value: className,
159 writable: true
160 })
161
162 return err
163 }
164
165 inherits(ClientError, HttpError)
166 nameFunc(ClientError, className)
167
168 ClientError.prototype.status = code
169 ClientError.prototype.statusCode = code
170 ClientError.prototype.expose = true
171
172 return ClientError
173}
174
175/**
176 * Create a constructor for a server error.
177 * @private
178 */
179
180function createServerErrorConstructor (HttpError, name, code) {
181 var className = name.match(/Error$/) ? name : name + 'Error'
182
183 function ServerError (message) {
184 // create the error object
185 var msg = message != null ? message : statuses[code]
186 var err = new Error(msg)
187
188 // capture a stack trace to the construction point
189 Error.captureStackTrace(err, ServerError)
190
191 // adjust the [[Prototype]]
192 setPrototypeOf(err, ServerError.prototype)
193
194 // redefine the error message
195 Object.defineProperty(err, 'message', {
196 enumerable: true,
197 configurable: true,
198 value: msg,
199 writable: true
200 })
201
202 // redefine the error name
203 Object.defineProperty(err, 'name', {
204 enumerable: false,
205 configurable: true,
206 value: className,
207 writable: true
208 })
209
210 return err
211 }
212
213 inherits(ServerError, HttpError)
214 nameFunc(ServerError, className)
215
216 ServerError.prototype.status = code
217 ServerError.prototype.statusCode = code
218 ServerError.prototype.expose = false
219
220 return ServerError
221}
222
223/**
224 * Set the name of a function, if possible.
225 * @private
226 */
227
228function nameFunc (func, name) {
229 var desc = Object.getOwnPropertyDescriptor(func, 'name')
230
231 if (desc && desc.configurable) {
232 desc.value = name
233 Object.defineProperty(func, 'name', desc)
234 }
235}
236
237/**
238 * Populate the exports object with constructors for every error class.
239 * @private
240 */
241
242function populateConstructorExports (exports, codes, HttpError) {
243 codes.forEach(function forEachCode (code) {
244 var CodeError
245 var name = toIdentifier(statuses[code])
246
247 switch (codeClass(code)) {
248 case 400:
249 CodeError = createClientErrorConstructor(HttpError, name, code)
250 break
251 case 500:
252 CodeError = createServerErrorConstructor(HttpError, name, code)
253 break
254 }
255
256 if (CodeError) {
257 // export the constructor
258 exports[code] = CodeError
259 exports[name] = CodeError
260 }
261 })
262
263 // backwards-compatibility
264 exports["I'mateapot"] = deprecate.function(exports.ImATeapot,
265 '"I\'mateapot"; use "ImATeapot" instead')
266}
Note: See TracBrowser for help on using the repository browser.