@sebspark/openapi-core 1.4.1 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/index.d.mts +44 -48
  2. package/dist/index.d.ts +44 -48
  3. package/dist/index.js +137 -139
  4. package/dist/index.mjs +137 -139
  5. package/package.json +2 -1
package/dist/index.d.mts CHANGED
@@ -8,138 +8,134 @@ type ServerErrorCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510
8
8
  type ErrorCode = ClientErrorCode | ServerErrorCode;
9
9
  type SerializedError = {
10
10
  message: string;
11
- internalError?: {
12
- message: string;
13
- stack?: string;
14
- };
11
+ stack?: string;
15
12
  };
16
13
  declare class HttpError extends Error {
17
14
  statusCode: number;
18
- internalError?: Error;
19
- constructor(statusCode: number, message: string, internalError?: Error);
20
- toJSON(includeInternalError?: boolean): SerializedError;
15
+ constructor(statusCode: number, message: string, cause?: Error);
16
+ toJSON(showStack?: boolean): SerializedError;
21
17
  }
22
18
  declare class BadRequestError extends HttpError {
23
- constructor(message?: string, internalError?: Error);
19
+ constructor(message?: string, cause?: Error);
24
20
  }
25
21
  declare class UnauthorizedError extends HttpError {
26
- constructor(message?: string, internalError?: Error);
22
+ constructor(message?: string, cause?: Error);
27
23
  }
28
24
  declare class PaymentRequiredError extends HttpError {
29
- constructor(message?: string, internalError?: Error);
25
+ constructor(message?: string, cause?: Error);
30
26
  }
31
27
  declare class ForbiddenError extends HttpError {
32
- constructor(message?: string, internalError?: Error);
28
+ constructor(message?: string, cause?: Error);
33
29
  }
34
30
  declare class NotFoundError extends HttpError {
35
- constructor(message?: string, internalError?: Error);
31
+ constructor(message?: string, cause?: Error);
36
32
  }
37
33
  declare class MethodNotAllowedError extends HttpError {
38
- constructor(message?: string, internalError?: Error);
34
+ constructor(message?: string, cause?: Error);
39
35
  }
40
36
  declare class NotAcceptableError extends HttpError {
41
- constructor(message?: string, internalError?: Error);
37
+ constructor(message?: string, cause?: Error);
42
38
  }
43
39
  declare class ProxyAuthenticationRequiredError extends HttpError {
44
- constructor(message?: string, internalError?: Error);
40
+ constructor(message?: string, cause?: Error);
45
41
  }
46
42
  declare class RequestTimeoutError extends HttpError {
47
- constructor(message?: string, internalError?: Error);
43
+ constructor(message?: string, cause?: Error);
48
44
  }
49
45
  declare class ConflictError extends HttpError {
50
- constructor(message?: string, internalError?: Error);
46
+ constructor(message?: string, cause?: Error);
51
47
  }
52
48
  declare class GoneError extends HttpError {
53
- constructor(message?: string, internalError?: Error);
49
+ constructor(message?: string, cause?: Error);
54
50
  }
55
51
  declare class LengthRequiredError extends HttpError {
56
- constructor(message?: string, internalError?: Error);
52
+ constructor(message?: string, cause?: Error);
57
53
  }
58
54
  declare class PreconditionFailedError extends HttpError {
59
- constructor(message?: string, internalError?: Error);
55
+ constructor(message?: string, cause?: Error);
60
56
  }
61
57
  declare class PayloadTooLargeError extends HttpError {
62
- constructor(message?: string, internalError?: Error);
58
+ constructor(message?: string, cause?: Error);
63
59
  }
64
60
  declare class URITooLongError extends HttpError {
65
- constructor(message?: string, internalError?: Error);
61
+ constructor(message?: string, cause?: Error);
66
62
  }
67
63
  declare class UnsupportedMediaTypeError extends HttpError {
68
- constructor(message?: string, internalError?: Error);
64
+ constructor(message?: string, cause?: Error);
69
65
  }
70
66
  declare class RangeNotSatisfiableError extends HttpError {
71
- constructor(message?: string, internalError?: Error);
67
+ constructor(message?: string, cause?: Error);
72
68
  }
73
69
  declare class ExpectationFailedError extends HttpError {
74
- constructor(message?: string, internalError?: Error);
70
+ constructor(message?: string, cause?: Error);
75
71
  }
76
72
  declare class IMATeapotError extends HttpError {
77
- constructor(message?: string, internalError?: Error);
73
+ constructor(message?: string, cause?: Error);
78
74
  }
79
75
  declare class MisdirectedRequestError extends HttpError {
80
- constructor(message?: string, internalError?: Error);
76
+ constructor(message?: string, cause?: Error);
81
77
  }
82
78
  declare class UnprocessableEntityError extends HttpError {
83
- constructor(message?: string, internalError?: Error);
79
+ constructor(message?: string, cause?: Error);
84
80
  }
85
81
  declare class LockedError extends HttpError {
86
- constructor(message?: string, internalError?: Error);
82
+ constructor(message?: string, cause?: Error);
87
83
  }
88
84
  declare class FailedDependencyError extends HttpError {
89
- constructor(message?: string, internalError?: Error);
85
+ constructor(message?: string, cause?: Error);
90
86
  }
91
87
  declare class TooEarlyError extends HttpError {
92
- constructor(message?: string, internalError?: Error);
88
+ constructor(message?: string, cause?: Error);
93
89
  }
94
90
  declare class UpgradeRequiredError extends HttpError {
95
- constructor(message?: string, internalError?: Error);
91
+ constructor(message?: string, cause?: Error);
96
92
  }
97
93
  declare class PreconditionRequiredError extends HttpError {
98
- constructor(message?: string, internalError?: Error);
94
+ constructor(message?: string, cause?: Error);
99
95
  }
100
96
  declare class TooManyRequestsError extends HttpError {
101
- constructor(message?: string, internalError?: Error);
97
+ constructor(message?: string, cause?: Error);
102
98
  }
103
99
  declare class RequestHeaderFieldsTooLargeError extends HttpError {
104
- constructor(message?: string, internalError?: Error);
100
+ constructor(message?: string, cause?: Error);
105
101
  }
106
102
  declare class UnavailableForLegalReasonsError extends HttpError {
107
- constructor(message?: string, internalError?: Error);
103
+ constructor(message?: string, cause?: Error);
108
104
  }
109
105
  declare class InternalServerError extends HttpError {
110
- constructor(message?: string, internalError?: Error);
106
+ constructor(message?: string, cause?: Error);
111
107
  }
112
108
  declare class NotImplementedError extends HttpError {
113
- constructor(message?: string, internalError?: Error);
109
+ constructor(message?: string, cause?: Error);
114
110
  }
115
111
  declare class BadGatewayError extends HttpError {
116
- constructor(message?: string, internalError?: Error);
112
+ constructor(message?: string, cause?: Error);
117
113
  }
118
114
  declare class ServiceUnavailableError extends HttpError {
119
- constructor(message?: string, internalError?: Error);
115
+ constructor(message?: string, cause?: Error);
120
116
  }
121
117
  declare class GatewayTimeoutError extends HttpError {
122
- constructor(message?: string, internalError?: Error);
118
+ constructor(message?: string, cause?: Error);
123
119
  }
124
120
  declare class HTTPVersionNotSupportedError extends HttpError {
125
- constructor(message?: string, internalError?: Error);
121
+ constructor(message?: string, cause?: Error);
126
122
  }
127
123
  declare class VariantAlsoNegotiatesError extends HttpError {
128
- constructor(message?: string, internalError?: Error);
124
+ constructor(message?: string, cause?: Error);
129
125
  }
130
126
  declare class InsufficientStorageError extends HttpError {
131
- constructor(message?: string, internalError?: Error);
127
+ constructor(message?: string, cause?: Error);
132
128
  }
133
129
  declare class LoopDetectedError extends HttpError {
134
- constructor(message?: string, internalError?: Error);
130
+ constructor(message?: string, cause?: Error);
135
131
  }
136
132
  declare class NotExtendedError extends HttpError {
137
- constructor(message?: string, internalError?: Error);
133
+ constructor(message?: string, cause?: Error);
138
134
  }
139
135
  declare class NetworkAuthenticationRequiredError extends HttpError {
140
- constructor(message?: string, internalError?: Error);
136
+ constructor(message?: string, cause?: Error);
141
137
  }
142
- declare const createHttpError: (statusCode: ErrorCode, message?: string, internalError?: Error) => HttpError;
138
+ declare const createHttpError: (statusCode: ErrorCode, message?: string, cause?: Error) => HttpError;
143
139
  declare const fromAxiosError: (axiosError: AxiosError) => HttpError;
144
140
 
145
141
  type Empty = Record<never, never>;
package/dist/index.d.ts CHANGED
@@ -8,138 +8,134 @@ type ServerErrorCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510
8
8
  type ErrorCode = ClientErrorCode | ServerErrorCode;
9
9
  type SerializedError = {
10
10
  message: string;
11
- internalError?: {
12
- message: string;
13
- stack?: string;
14
- };
11
+ stack?: string;
15
12
  };
16
13
  declare class HttpError extends Error {
17
14
  statusCode: number;
18
- internalError?: Error;
19
- constructor(statusCode: number, message: string, internalError?: Error);
20
- toJSON(includeInternalError?: boolean): SerializedError;
15
+ constructor(statusCode: number, message: string, cause?: Error);
16
+ toJSON(showStack?: boolean): SerializedError;
21
17
  }
22
18
  declare class BadRequestError extends HttpError {
23
- constructor(message?: string, internalError?: Error);
19
+ constructor(message?: string, cause?: Error);
24
20
  }
25
21
  declare class UnauthorizedError extends HttpError {
26
- constructor(message?: string, internalError?: Error);
22
+ constructor(message?: string, cause?: Error);
27
23
  }
28
24
  declare class PaymentRequiredError extends HttpError {
29
- constructor(message?: string, internalError?: Error);
25
+ constructor(message?: string, cause?: Error);
30
26
  }
31
27
  declare class ForbiddenError extends HttpError {
32
- constructor(message?: string, internalError?: Error);
28
+ constructor(message?: string, cause?: Error);
33
29
  }
34
30
  declare class NotFoundError extends HttpError {
35
- constructor(message?: string, internalError?: Error);
31
+ constructor(message?: string, cause?: Error);
36
32
  }
37
33
  declare class MethodNotAllowedError extends HttpError {
38
- constructor(message?: string, internalError?: Error);
34
+ constructor(message?: string, cause?: Error);
39
35
  }
40
36
  declare class NotAcceptableError extends HttpError {
41
- constructor(message?: string, internalError?: Error);
37
+ constructor(message?: string, cause?: Error);
42
38
  }
43
39
  declare class ProxyAuthenticationRequiredError extends HttpError {
44
- constructor(message?: string, internalError?: Error);
40
+ constructor(message?: string, cause?: Error);
45
41
  }
46
42
  declare class RequestTimeoutError extends HttpError {
47
- constructor(message?: string, internalError?: Error);
43
+ constructor(message?: string, cause?: Error);
48
44
  }
49
45
  declare class ConflictError extends HttpError {
50
- constructor(message?: string, internalError?: Error);
46
+ constructor(message?: string, cause?: Error);
51
47
  }
52
48
  declare class GoneError extends HttpError {
53
- constructor(message?: string, internalError?: Error);
49
+ constructor(message?: string, cause?: Error);
54
50
  }
55
51
  declare class LengthRequiredError extends HttpError {
56
- constructor(message?: string, internalError?: Error);
52
+ constructor(message?: string, cause?: Error);
57
53
  }
58
54
  declare class PreconditionFailedError extends HttpError {
59
- constructor(message?: string, internalError?: Error);
55
+ constructor(message?: string, cause?: Error);
60
56
  }
61
57
  declare class PayloadTooLargeError extends HttpError {
62
- constructor(message?: string, internalError?: Error);
58
+ constructor(message?: string, cause?: Error);
63
59
  }
64
60
  declare class URITooLongError extends HttpError {
65
- constructor(message?: string, internalError?: Error);
61
+ constructor(message?: string, cause?: Error);
66
62
  }
67
63
  declare class UnsupportedMediaTypeError extends HttpError {
68
- constructor(message?: string, internalError?: Error);
64
+ constructor(message?: string, cause?: Error);
69
65
  }
70
66
  declare class RangeNotSatisfiableError extends HttpError {
71
- constructor(message?: string, internalError?: Error);
67
+ constructor(message?: string, cause?: Error);
72
68
  }
73
69
  declare class ExpectationFailedError extends HttpError {
74
- constructor(message?: string, internalError?: Error);
70
+ constructor(message?: string, cause?: Error);
75
71
  }
76
72
  declare class IMATeapotError extends HttpError {
77
- constructor(message?: string, internalError?: Error);
73
+ constructor(message?: string, cause?: Error);
78
74
  }
79
75
  declare class MisdirectedRequestError extends HttpError {
80
- constructor(message?: string, internalError?: Error);
76
+ constructor(message?: string, cause?: Error);
81
77
  }
82
78
  declare class UnprocessableEntityError extends HttpError {
83
- constructor(message?: string, internalError?: Error);
79
+ constructor(message?: string, cause?: Error);
84
80
  }
85
81
  declare class LockedError extends HttpError {
86
- constructor(message?: string, internalError?: Error);
82
+ constructor(message?: string, cause?: Error);
87
83
  }
88
84
  declare class FailedDependencyError extends HttpError {
89
- constructor(message?: string, internalError?: Error);
85
+ constructor(message?: string, cause?: Error);
90
86
  }
91
87
  declare class TooEarlyError extends HttpError {
92
- constructor(message?: string, internalError?: Error);
88
+ constructor(message?: string, cause?: Error);
93
89
  }
94
90
  declare class UpgradeRequiredError extends HttpError {
95
- constructor(message?: string, internalError?: Error);
91
+ constructor(message?: string, cause?: Error);
96
92
  }
97
93
  declare class PreconditionRequiredError extends HttpError {
98
- constructor(message?: string, internalError?: Error);
94
+ constructor(message?: string, cause?: Error);
99
95
  }
100
96
  declare class TooManyRequestsError extends HttpError {
101
- constructor(message?: string, internalError?: Error);
97
+ constructor(message?: string, cause?: Error);
102
98
  }
103
99
  declare class RequestHeaderFieldsTooLargeError extends HttpError {
104
- constructor(message?: string, internalError?: Error);
100
+ constructor(message?: string, cause?: Error);
105
101
  }
106
102
  declare class UnavailableForLegalReasonsError extends HttpError {
107
- constructor(message?: string, internalError?: Error);
103
+ constructor(message?: string, cause?: Error);
108
104
  }
109
105
  declare class InternalServerError extends HttpError {
110
- constructor(message?: string, internalError?: Error);
106
+ constructor(message?: string, cause?: Error);
111
107
  }
112
108
  declare class NotImplementedError extends HttpError {
113
- constructor(message?: string, internalError?: Error);
109
+ constructor(message?: string, cause?: Error);
114
110
  }
115
111
  declare class BadGatewayError extends HttpError {
116
- constructor(message?: string, internalError?: Error);
112
+ constructor(message?: string, cause?: Error);
117
113
  }
118
114
  declare class ServiceUnavailableError extends HttpError {
119
- constructor(message?: string, internalError?: Error);
115
+ constructor(message?: string, cause?: Error);
120
116
  }
121
117
  declare class GatewayTimeoutError extends HttpError {
122
- constructor(message?: string, internalError?: Error);
118
+ constructor(message?: string, cause?: Error);
123
119
  }
124
120
  declare class HTTPVersionNotSupportedError extends HttpError {
125
- constructor(message?: string, internalError?: Error);
121
+ constructor(message?: string, cause?: Error);
126
122
  }
127
123
  declare class VariantAlsoNegotiatesError extends HttpError {
128
- constructor(message?: string, internalError?: Error);
124
+ constructor(message?: string, cause?: Error);
129
125
  }
130
126
  declare class InsufficientStorageError extends HttpError {
131
- constructor(message?: string, internalError?: Error);
127
+ constructor(message?: string, cause?: Error);
132
128
  }
133
129
  declare class LoopDetectedError extends HttpError {
134
- constructor(message?: string, internalError?: Error);
130
+ constructor(message?: string, cause?: Error);
135
131
  }
136
132
  declare class NotExtendedError extends HttpError {
137
- constructor(message?: string, internalError?: Error);
133
+ constructor(message?: string, cause?: Error);
138
134
  }
139
135
  declare class NetworkAuthenticationRequiredError extends HttpError {
140
- constructor(message?: string, internalError?: Error);
136
+ constructor(message?: string, cause?: Error);
141
137
  }
142
- declare const createHttpError: (statusCode: ErrorCode, message?: string, internalError?: Error) => HttpError;
138
+ declare const createHttpError: (statusCode: ErrorCode, message?: string, cause?: Error) => HttpError;
143
139
  declare const fromAxiosError: (axiosError: AxiosError) => HttpError;
144
140
 
145
141
  type Empty = Record<never, never>;
package/dist/index.js CHANGED
@@ -67,323 +67,321 @@ __export(src_exports, {
67
67
  module.exports = __toCommonJS(src_exports);
68
68
 
69
69
  // src/errors.ts
70
+ var import_node_util = require("util");
70
71
  var HttpError = class _HttpError extends Error {
71
72
  statusCode;
72
- internalError;
73
- constructor(statusCode, message, internalError) {
73
+ constructor(statusCode, message, cause) {
74
74
  super(message);
75
+ if (cause) {
76
+ this.stack = void 0;
77
+ this.cause = cause;
78
+ }
75
79
  this.statusCode = statusCode;
76
- this.internalError = internalError;
77
80
  Object.setPrototypeOf(this, _HttpError.prototype);
78
81
  }
79
- toJSON(includeInternalError = false) {
80
- var _a;
82
+ toJSON(showStack = false) {
81
83
  const serialized = {
82
84
  message: this.message
83
85
  };
84
- if (includeInternalError && this.internalError) {
85
- serialized.internalError = {
86
- message: this.internalError.message,
87
- stack: (_a = this.internalError) == null ? void 0 : _a.stack
88
- };
86
+ if (showStack) {
87
+ serialized.stack = (0, import_node_util.inspect)(this);
89
88
  }
90
89
  return serialized;
91
90
  }
92
91
  };
93
92
  var BadRequestError = class extends HttpError {
94
- constructor(message = "Bad Request", internalError) {
95
- super(400, message, internalError);
93
+ constructor(message = "Bad Request", cause) {
94
+ super(400, message, cause);
96
95
  }
97
96
  };
98
97
  var UnauthorizedError = class extends HttpError {
99
- constructor(message = "Unauthorized", internalError) {
100
- super(401, message, internalError);
98
+ constructor(message = "Unauthorized", cause) {
99
+ super(401, message, cause);
101
100
  }
102
101
  };
103
102
  var PaymentRequiredError = class extends HttpError {
104
- constructor(message = "Payment Required", internalError) {
105
- super(402, message, internalError);
103
+ constructor(message = "Payment Required", cause) {
104
+ super(402, message, cause);
106
105
  }
107
106
  };
108
107
  var ForbiddenError = class extends HttpError {
109
- constructor(message = "Forbidden", internalError) {
110
- super(403, message, internalError);
108
+ constructor(message = "Forbidden", cause) {
109
+ super(403, message, cause);
111
110
  }
112
111
  };
113
112
  var NotFoundError = class extends HttpError {
114
- constructor(message = "Not Found", internalError) {
115
- super(404, message, internalError);
113
+ constructor(message = "Not Found", cause) {
114
+ super(404, message, cause);
116
115
  }
117
116
  };
118
117
  var MethodNotAllowedError = class extends HttpError {
119
- constructor(message = "Method Not Allowed", internalError) {
120
- super(405, message, internalError);
118
+ constructor(message = "Method Not Allowed", cause) {
119
+ super(405, message, cause);
121
120
  }
122
121
  };
123
122
  var NotAcceptableError = class extends HttpError {
124
- constructor(message = "Not Acceptable", internalError) {
125
- super(406, message, internalError);
123
+ constructor(message = "Not Acceptable", cause) {
124
+ super(406, message, cause);
126
125
  }
127
126
  };
128
127
  var ProxyAuthenticationRequiredError = class extends HttpError {
129
- constructor(message = "Proxy Authentication Required", internalError) {
130
- super(407, message, internalError);
128
+ constructor(message = "Proxy Authentication Required", cause) {
129
+ super(407, message, cause);
131
130
  }
132
131
  };
133
132
  var RequestTimeoutError = class extends HttpError {
134
- constructor(message = "Request Timeout", internalError) {
135
- super(408, message, internalError);
133
+ constructor(message = "Request Timeout", cause) {
134
+ super(408, message, cause);
136
135
  }
137
136
  };
138
137
  var ConflictError = class extends HttpError {
139
- constructor(message = "Conflict", internalError) {
140
- super(409, message, internalError);
138
+ constructor(message = "Conflict", cause) {
139
+ super(409, message, cause);
141
140
  }
142
141
  };
143
142
  var GoneError = class extends HttpError {
144
- constructor(message = "Gone", internalError) {
145
- super(410, message, internalError);
143
+ constructor(message = "Gone", cause) {
144
+ super(410, message, cause);
146
145
  }
147
146
  };
148
147
  var LengthRequiredError = class extends HttpError {
149
- constructor(message = "Length Required", internalError) {
150
- super(411, message, internalError);
148
+ constructor(message = "Length Required", cause) {
149
+ super(411, message, cause);
151
150
  }
152
151
  };
153
152
  var PreconditionFailedError = class extends HttpError {
154
- constructor(message = "Precondition Failed", internalError) {
155
- super(412, message, internalError);
153
+ constructor(message = "Precondition Failed", cause) {
154
+ super(412, message, cause);
156
155
  }
157
156
  };
158
157
  var PayloadTooLargeError = class extends HttpError {
159
- constructor(message = "Payload Too Large", internalError) {
160
- super(413, message, internalError);
158
+ constructor(message = "Payload Too Large", cause) {
159
+ super(413, message, cause);
161
160
  }
162
161
  };
163
162
  var URITooLongError = class extends HttpError {
164
- constructor(message = "URI Too Long", internalError) {
165
- super(414, message, internalError);
163
+ constructor(message = "URI Too Long", cause) {
164
+ super(414, message, cause);
166
165
  }
167
166
  };
168
167
  var UnsupportedMediaTypeError = class extends HttpError {
169
- constructor(message = "Unsupported Media Type", internalError) {
170
- super(415, message, internalError);
168
+ constructor(message = "Unsupported Media Type", cause) {
169
+ super(415, message, cause);
171
170
  }
172
171
  };
173
172
  var RangeNotSatisfiableError = class extends HttpError {
174
- constructor(message = "Range Not Satisfiable", internalError) {
175
- super(416, message, internalError);
173
+ constructor(message = "Range Not Satisfiable", cause) {
174
+ super(416, message, cause);
176
175
  }
177
176
  };
178
177
  var ExpectationFailedError = class extends HttpError {
179
- constructor(message = "Expectation Failed", internalError) {
180
- super(417, message, internalError);
178
+ constructor(message = "Expectation Failed", cause) {
179
+ super(417, message, cause);
181
180
  }
182
181
  };
183
182
  var IMATeapotError = class extends HttpError {
184
- constructor(message = "I'm a teapot", internalError) {
185
- super(418, message, internalError);
183
+ constructor(message = "I'm a teapot", cause) {
184
+ super(418, message, cause);
186
185
  }
187
186
  };
188
187
  var MisdirectedRequestError = class extends HttpError {
189
- constructor(message = "Misdirected Request", internalError) {
190
- super(421, message, internalError);
188
+ constructor(message = "Misdirected Request", cause) {
189
+ super(421, message, cause);
191
190
  }
192
191
  };
193
192
  var UnprocessableEntityError = class extends HttpError {
194
- constructor(message = "Unprocessable Entity", internalError) {
195
- super(422, message, internalError);
193
+ constructor(message = "Unprocessable Entity", cause) {
194
+ super(422, message, cause);
196
195
  }
197
196
  };
198
197
  var LockedError = class extends HttpError {
199
- constructor(message = "Locked", internalError) {
200
- super(423, message, internalError);
198
+ constructor(message = "Locked", cause) {
199
+ super(423, message, cause);
201
200
  }
202
201
  };
203
202
  var FailedDependencyError = class extends HttpError {
204
- constructor(message = "Failed Dependency", internalError) {
205
- super(424, message, internalError);
203
+ constructor(message = "Failed Dependency", cause) {
204
+ super(424, message, cause);
206
205
  }
207
206
  };
208
207
  var TooEarlyError = class extends HttpError {
209
- constructor(message = "Too Early", internalError) {
210
- super(425, message, internalError);
208
+ constructor(message = "Too Early", cause) {
209
+ super(425, message, cause);
211
210
  }
212
211
  };
213
212
  var UpgradeRequiredError = class extends HttpError {
214
- constructor(message = "Upgrade Required", internalError) {
215
- super(426, message, internalError);
213
+ constructor(message = "Upgrade Required", cause) {
214
+ super(426, message, cause);
216
215
  }
217
216
  };
218
217
  var PreconditionRequiredError = class extends HttpError {
219
- constructor(message = "Precondition Required", internalError) {
220
- super(428, message, internalError);
218
+ constructor(message = "Precondition Required", cause) {
219
+ super(428, message, cause);
221
220
  }
222
221
  };
223
222
  var TooManyRequestsError = class extends HttpError {
224
- constructor(message = "Too Many Requests", internalError) {
225
- super(429, message, internalError);
223
+ constructor(message = "Too Many Requests", cause) {
224
+ super(429, message, cause);
226
225
  }
227
226
  };
228
227
  var RequestHeaderFieldsTooLargeError = class extends HttpError {
229
- constructor(message = "Request Header Fields Too Large", internalError) {
230
- super(431, message, internalError);
228
+ constructor(message = "Request Header Fields Too Large", cause) {
229
+ super(431, message, cause);
231
230
  }
232
231
  };
233
232
  var UnavailableForLegalReasonsError = class extends HttpError {
234
- constructor(message = "Unavailable For Legal Reasons", internalError) {
235
- super(451, message, internalError);
233
+ constructor(message = "Unavailable For Legal Reasons", cause) {
234
+ super(451, message, cause);
236
235
  }
237
236
  };
238
237
  var InternalServerError = class extends HttpError {
239
- constructor(message = "Internal Server Error", internalError) {
240
- super(500, message, internalError);
238
+ constructor(message = "Internal Server Error", cause) {
239
+ super(500, message, cause);
241
240
  }
242
241
  };
243
242
  var NotImplementedError = class extends HttpError {
244
- constructor(message = "Not Implemented", internalError) {
245
- super(501, message, internalError);
243
+ constructor(message = "Not Implemented", cause) {
244
+ super(501, message, cause);
246
245
  }
247
246
  };
248
247
  var BadGatewayError = class extends HttpError {
249
- constructor(message = "Bad Gateway", internalError) {
250
- super(502, message, internalError);
248
+ constructor(message = "Bad Gateway", cause) {
249
+ super(502, message, cause);
251
250
  }
252
251
  };
253
252
  var ServiceUnavailableError = class extends HttpError {
254
- constructor(message = "Service Unavailable", internalError) {
255
- super(503, message, internalError);
253
+ constructor(message = "Service Unavailable", cause) {
254
+ super(503, message, cause);
256
255
  }
257
256
  };
258
257
  var GatewayTimeoutError = class extends HttpError {
259
- constructor(message = "Gateway Timeout", internalError) {
260
- super(504, message, internalError);
258
+ constructor(message = "Gateway Timeout", cause) {
259
+ super(504, message, cause);
261
260
  }
262
261
  };
263
262
  var HTTPVersionNotSupportedError = class extends HttpError {
264
- constructor(message = "HTTP Version Not Supported", internalError) {
265
- super(505, message, internalError);
263
+ constructor(message = "HTTP Version Not Supported", cause) {
264
+ super(505, message, cause);
266
265
  }
267
266
  };
268
267
  var VariantAlsoNegotiatesError = class extends HttpError {
269
- constructor(message = "Variant Also Negotiates", internalError) {
270
- super(506, message, internalError);
268
+ constructor(message = "Variant Also Negotiates", cause) {
269
+ super(506, message, cause);
271
270
  }
272
271
  };
273
272
  var InsufficientStorageError = class extends HttpError {
274
- constructor(message = "Insufficient Storage", internalError) {
275
- super(507, message, internalError);
273
+ constructor(message = "Insufficient Storage", cause) {
274
+ super(507, message, cause);
276
275
  }
277
276
  };
278
277
  var LoopDetectedError = class extends HttpError {
279
- constructor(message = "Loop Detected", internalError) {
280
- super(508, message, internalError);
278
+ constructor(message = "Loop Detected", cause) {
279
+ super(508, message, cause);
281
280
  }
282
281
  };
283
282
  var NotExtendedError = class extends HttpError {
284
- constructor(message = "Not Extended", internalError) {
285
- super(510, message, internalError);
283
+ constructor(message = "Not Extended", cause) {
284
+ super(510, message, cause);
286
285
  }
287
286
  };
288
287
  var NetworkAuthenticationRequiredError = class extends HttpError {
289
- constructor(message = "Network Authentication Required", internalError) {
290
- super(511, message, internalError);
288
+ constructor(message = "Network Authentication Required", cause) {
289
+ super(511, message, cause);
291
290
  }
292
291
  };
293
- var createHttpError = (statusCode, message, internalError) => {
292
+ var createHttpError = (statusCode, message, cause) => {
294
293
  switch (statusCode) {
295
294
  case 400:
296
- return new BadRequestError(message, internalError);
295
+ return new BadRequestError(message, cause);
297
296
  case 401:
298
- return new UnauthorizedError(message, internalError);
297
+ return new UnauthorizedError(message, cause);
299
298
  case 402:
300
- return new PaymentRequiredError(message, internalError);
299
+ return new PaymentRequiredError(message, cause);
301
300
  case 403:
302
- return new ForbiddenError(message, internalError);
301
+ return new ForbiddenError(message, cause);
303
302
  case 404:
304
- return new NotFoundError(message, internalError);
303
+ return new NotFoundError(message, cause);
305
304
  case 405:
306
- return new MethodNotAllowedError(message, internalError);
305
+ return new MethodNotAllowedError(message, cause);
307
306
  case 406:
308
- return new NotAcceptableError(message, internalError);
307
+ return new NotAcceptableError(message, cause);
309
308
  case 407:
310
- return new ProxyAuthenticationRequiredError(message, internalError);
309
+ return new ProxyAuthenticationRequiredError(message, cause);
311
310
  case 408:
312
- return new RequestTimeoutError(message, internalError);
311
+ return new RequestTimeoutError(message, cause);
313
312
  case 409:
314
- return new ConflictError(message, internalError);
313
+ return new ConflictError(message, cause);
315
314
  case 410:
316
- return new GoneError(message, internalError);
315
+ return new GoneError(message, cause);
317
316
  case 411:
318
- return new LengthRequiredError(message, internalError);
317
+ return new LengthRequiredError(message, cause);
319
318
  case 412:
320
- return new PreconditionFailedError(message, internalError);
319
+ return new PreconditionFailedError(message, cause);
321
320
  case 413:
322
- return new PayloadTooLargeError(message, internalError);
321
+ return new PayloadTooLargeError(message, cause);
323
322
  case 414:
324
- return new URITooLongError(message, internalError);
323
+ return new URITooLongError(message, cause);
325
324
  case 415:
326
- return new UnsupportedMediaTypeError(message, internalError);
325
+ return new UnsupportedMediaTypeError(message, cause);
327
326
  case 416:
328
- return new RangeNotSatisfiableError(message, internalError);
327
+ return new RangeNotSatisfiableError(message, cause);
329
328
  case 417:
330
- return new ExpectationFailedError(message, internalError);
329
+ return new ExpectationFailedError(message, cause);
331
330
  case 418:
332
- return new IMATeapotError(message, internalError);
331
+ return new IMATeapotError(message, cause);
333
332
  case 421:
334
- return new MisdirectedRequestError(message, internalError);
333
+ return new MisdirectedRequestError(message, cause);
335
334
  case 422:
336
- return new UnprocessableEntityError(message, internalError);
335
+ return new UnprocessableEntityError(message, cause);
337
336
  case 423:
338
- return new LockedError(message, internalError);
337
+ return new LockedError(message, cause);
339
338
  case 424:
340
- return new FailedDependencyError(message, internalError);
339
+ return new FailedDependencyError(message, cause);
341
340
  case 425:
342
- return new TooEarlyError(message, internalError);
341
+ return new TooEarlyError(message, cause);
343
342
  case 426:
344
- return new UpgradeRequiredError(message, internalError);
343
+ return new UpgradeRequiredError(message, cause);
345
344
  case 428:
346
- return new PreconditionRequiredError(message, internalError);
345
+ return new PreconditionRequiredError(message, cause);
347
346
  case 429:
348
- return new TooManyRequestsError(message, internalError);
347
+ return new TooManyRequestsError(message, cause);
349
348
  case 431:
350
- return new RequestHeaderFieldsTooLargeError(message, internalError);
349
+ return new RequestHeaderFieldsTooLargeError(message, cause);
351
350
  case 451:
352
- return new UnavailableForLegalReasonsError(message, internalError);
351
+ return new UnavailableForLegalReasonsError(message, cause);
353
352
  case 500:
354
- return new InternalServerError(message, internalError);
353
+ return new InternalServerError(message, cause);
355
354
  case 501:
356
- return new NotImplementedError(message, internalError);
355
+ return new NotImplementedError(message, cause);
357
356
  case 502:
358
- return new BadGatewayError(message, internalError);
357
+ return new BadGatewayError(message, cause);
359
358
  case 503:
360
- return new ServiceUnavailableError(message, internalError);
359
+ return new ServiceUnavailableError(message, cause);
361
360
  case 504:
362
- return new GatewayTimeoutError(message, internalError);
361
+ return new GatewayTimeoutError(message, cause);
363
362
  case 505:
364
- return new HTTPVersionNotSupportedError(message, internalError);
363
+ return new HTTPVersionNotSupportedError(message, cause);
365
364
  case 506:
366
- return new VariantAlsoNegotiatesError(message, internalError);
365
+ return new VariantAlsoNegotiatesError(message, cause);
367
366
  case 507:
368
- return new InsufficientStorageError(message, internalError);
367
+ return new InsufficientStorageError(message, cause);
369
368
  case 508:
370
- return new LoopDetectedError(message, internalError);
369
+ return new LoopDetectedError(message, cause);
371
370
  case 510:
372
- return new NotExtendedError(message, internalError);
371
+ return new NotExtendedError(message, cause);
373
372
  case 511:
374
- return new NetworkAuthenticationRequiredError(message, internalError);
373
+ return new NetworkAuthenticationRequiredError(message, cause);
375
374
  default:
376
- return new HttpError(statusCode, message ?? "Error");
375
+ return new HttpError(statusCode, message ?? "Error", cause);
377
376
  }
378
377
  };
379
378
  var fromAxiosError = (axiosError) => {
380
- var _a, _b;
381
- const statusCode = ((_a = axiosError.response) == null ? void 0 : _a.status) || 500;
382
- const message = ((_b = axiosError.response) == null ? void 0 : _b.statusText) || "Internal Server Error";
383
- const internalError = new Error(axiosError.message);
384
- internalError.name = axiosError.name;
385
- internalError.stack = axiosError.stack;
386
- return createHttpError(statusCode, message, internalError);
379
+ const statusCode = axiosError.response?.status || 500;
380
+ const message = axiosError.response?.statusText || "Internal Server Error";
381
+ const cause = new Error(axiosError.message);
382
+ cause.name = axiosError.name;
383
+ cause.stack = axiosError.stack;
384
+ return createHttpError(statusCode, message, cause);
387
385
  };
388
386
  // Annotate the CommonJS export names for ESM import in node:
389
387
  0 && (module.exports = {
package/dist/index.mjs CHANGED
@@ -1,321 +1,319 @@
1
1
  // src/errors.ts
2
+ import { inspect } from "node:util";
2
3
  var HttpError = class _HttpError extends Error {
3
4
  statusCode;
4
- internalError;
5
- constructor(statusCode, message, internalError) {
5
+ constructor(statusCode, message, cause) {
6
6
  super(message);
7
+ if (cause) {
8
+ this.stack = void 0;
9
+ this.cause = cause;
10
+ }
7
11
  this.statusCode = statusCode;
8
- this.internalError = internalError;
9
12
  Object.setPrototypeOf(this, _HttpError.prototype);
10
13
  }
11
- toJSON(includeInternalError = false) {
12
- var _a;
14
+ toJSON(showStack = false) {
13
15
  const serialized = {
14
16
  message: this.message
15
17
  };
16
- if (includeInternalError && this.internalError) {
17
- serialized.internalError = {
18
- message: this.internalError.message,
19
- stack: (_a = this.internalError) == null ? void 0 : _a.stack
20
- };
18
+ if (showStack) {
19
+ serialized.stack = inspect(this);
21
20
  }
22
21
  return serialized;
23
22
  }
24
23
  };
25
24
  var BadRequestError = class extends HttpError {
26
- constructor(message = "Bad Request", internalError) {
27
- super(400, message, internalError);
25
+ constructor(message = "Bad Request", cause) {
26
+ super(400, message, cause);
28
27
  }
29
28
  };
30
29
  var UnauthorizedError = class extends HttpError {
31
- constructor(message = "Unauthorized", internalError) {
32
- super(401, message, internalError);
30
+ constructor(message = "Unauthorized", cause) {
31
+ super(401, message, cause);
33
32
  }
34
33
  };
35
34
  var PaymentRequiredError = class extends HttpError {
36
- constructor(message = "Payment Required", internalError) {
37
- super(402, message, internalError);
35
+ constructor(message = "Payment Required", cause) {
36
+ super(402, message, cause);
38
37
  }
39
38
  };
40
39
  var ForbiddenError = class extends HttpError {
41
- constructor(message = "Forbidden", internalError) {
42
- super(403, message, internalError);
40
+ constructor(message = "Forbidden", cause) {
41
+ super(403, message, cause);
43
42
  }
44
43
  };
45
44
  var NotFoundError = class extends HttpError {
46
- constructor(message = "Not Found", internalError) {
47
- super(404, message, internalError);
45
+ constructor(message = "Not Found", cause) {
46
+ super(404, message, cause);
48
47
  }
49
48
  };
50
49
  var MethodNotAllowedError = class extends HttpError {
51
- constructor(message = "Method Not Allowed", internalError) {
52
- super(405, message, internalError);
50
+ constructor(message = "Method Not Allowed", cause) {
51
+ super(405, message, cause);
53
52
  }
54
53
  };
55
54
  var NotAcceptableError = class extends HttpError {
56
- constructor(message = "Not Acceptable", internalError) {
57
- super(406, message, internalError);
55
+ constructor(message = "Not Acceptable", cause) {
56
+ super(406, message, cause);
58
57
  }
59
58
  };
60
59
  var ProxyAuthenticationRequiredError = class extends HttpError {
61
- constructor(message = "Proxy Authentication Required", internalError) {
62
- super(407, message, internalError);
60
+ constructor(message = "Proxy Authentication Required", cause) {
61
+ super(407, message, cause);
63
62
  }
64
63
  };
65
64
  var RequestTimeoutError = class extends HttpError {
66
- constructor(message = "Request Timeout", internalError) {
67
- super(408, message, internalError);
65
+ constructor(message = "Request Timeout", cause) {
66
+ super(408, message, cause);
68
67
  }
69
68
  };
70
69
  var ConflictError = class extends HttpError {
71
- constructor(message = "Conflict", internalError) {
72
- super(409, message, internalError);
70
+ constructor(message = "Conflict", cause) {
71
+ super(409, message, cause);
73
72
  }
74
73
  };
75
74
  var GoneError = class extends HttpError {
76
- constructor(message = "Gone", internalError) {
77
- super(410, message, internalError);
75
+ constructor(message = "Gone", cause) {
76
+ super(410, message, cause);
78
77
  }
79
78
  };
80
79
  var LengthRequiredError = class extends HttpError {
81
- constructor(message = "Length Required", internalError) {
82
- super(411, message, internalError);
80
+ constructor(message = "Length Required", cause) {
81
+ super(411, message, cause);
83
82
  }
84
83
  };
85
84
  var PreconditionFailedError = class extends HttpError {
86
- constructor(message = "Precondition Failed", internalError) {
87
- super(412, message, internalError);
85
+ constructor(message = "Precondition Failed", cause) {
86
+ super(412, message, cause);
88
87
  }
89
88
  };
90
89
  var PayloadTooLargeError = class extends HttpError {
91
- constructor(message = "Payload Too Large", internalError) {
92
- super(413, message, internalError);
90
+ constructor(message = "Payload Too Large", cause) {
91
+ super(413, message, cause);
93
92
  }
94
93
  };
95
94
  var URITooLongError = class extends HttpError {
96
- constructor(message = "URI Too Long", internalError) {
97
- super(414, message, internalError);
95
+ constructor(message = "URI Too Long", cause) {
96
+ super(414, message, cause);
98
97
  }
99
98
  };
100
99
  var UnsupportedMediaTypeError = class extends HttpError {
101
- constructor(message = "Unsupported Media Type", internalError) {
102
- super(415, message, internalError);
100
+ constructor(message = "Unsupported Media Type", cause) {
101
+ super(415, message, cause);
103
102
  }
104
103
  };
105
104
  var RangeNotSatisfiableError = class extends HttpError {
106
- constructor(message = "Range Not Satisfiable", internalError) {
107
- super(416, message, internalError);
105
+ constructor(message = "Range Not Satisfiable", cause) {
106
+ super(416, message, cause);
108
107
  }
109
108
  };
110
109
  var ExpectationFailedError = class extends HttpError {
111
- constructor(message = "Expectation Failed", internalError) {
112
- super(417, message, internalError);
110
+ constructor(message = "Expectation Failed", cause) {
111
+ super(417, message, cause);
113
112
  }
114
113
  };
115
114
  var IMATeapotError = class extends HttpError {
116
- constructor(message = "I'm a teapot", internalError) {
117
- super(418, message, internalError);
115
+ constructor(message = "I'm a teapot", cause) {
116
+ super(418, message, cause);
118
117
  }
119
118
  };
120
119
  var MisdirectedRequestError = class extends HttpError {
121
- constructor(message = "Misdirected Request", internalError) {
122
- super(421, message, internalError);
120
+ constructor(message = "Misdirected Request", cause) {
121
+ super(421, message, cause);
123
122
  }
124
123
  };
125
124
  var UnprocessableEntityError = class extends HttpError {
126
- constructor(message = "Unprocessable Entity", internalError) {
127
- super(422, message, internalError);
125
+ constructor(message = "Unprocessable Entity", cause) {
126
+ super(422, message, cause);
128
127
  }
129
128
  };
130
129
  var LockedError = class extends HttpError {
131
- constructor(message = "Locked", internalError) {
132
- super(423, message, internalError);
130
+ constructor(message = "Locked", cause) {
131
+ super(423, message, cause);
133
132
  }
134
133
  };
135
134
  var FailedDependencyError = class extends HttpError {
136
- constructor(message = "Failed Dependency", internalError) {
137
- super(424, message, internalError);
135
+ constructor(message = "Failed Dependency", cause) {
136
+ super(424, message, cause);
138
137
  }
139
138
  };
140
139
  var TooEarlyError = class extends HttpError {
141
- constructor(message = "Too Early", internalError) {
142
- super(425, message, internalError);
140
+ constructor(message = "Too Early", cause) {
141
+ super(425, message, cause);
143
142
  }
144
143
  };
145
144
  var UpgradeRequiredError = class extends HttpError {
146
- constructor(message = "Upgrade Required", internalError) {
147
- super(426, message, internalError);
145
+ constructor(message = "Upgrade Required", cause) {
146
+ super(426, message, cause);
148
147
  }
149
148
  };
150
149
  var PreconditionRequiredError = class extends HttpError {
151
- constructor(message = "Precondition Required", internalError) {
152
- super(428, message, internalError);
150
+ constructor(message = "Precondition Required", cause) {
151
+ super(428, message, cause);
153
152
  }
154
153
  };
155
154
  var TooManyRequestsError = class extends HttpError {
156
- constructor(message = "Too Many Requests", internalError) {
157
- super(429, message, internalError);
155
+ constructor(message = "Too Many Requests", cause) {
156
+ super(429, message, cause);
158
157
  }
159
158
  };
160
159
  var RequestHeaderFieldsTooLargeError = class extends HttpError {
161
- constructor(message = "Request Header Fields Too Large", internalError) {
162
- super(431, message, internalError);
160
+ constructor(message = "Request Header Fields Too Large", cause) {
161
+ super(431, message, cause);
163
162
  }
164
163
  };
165
164
  var UnavailableForLegalReasonsError = class extends HttpError {
166
- constructor(message = "Unavailable For Legal Reasons", internalError) {
167
- super(451, message, internalError);
165
+ constructor(message = "Unavailable For Legal Reasons", cause) {
166
+ super(451, message, cause);
168
167
  }
169
168
  };
170
169
  var InternalServerError = class extends HttpError {
171
- constructor(message = "Internal Server Error", internalError) {
172
- super(500, message, internalError);
170
+ constructor(message = "Internal Server Error", cause) {
171
+ super(500, message, cause);
173
172
  }
174
173
  };
175
174
  var NotImplementedError = class extends HttpError {
176
- constructor(message = "Not Implemented", internalError) {
177
- super(501, message, internalError);
175
+ constructor(message = "Not Implemented", cause) {
176
+ super(501, message, cause);
178
177
  }
179
178
  };
180
179
  var BadGatewayError = class extends HttpError {
181
- constructor(message = "Bad Gateway", internalError) {
182
- super(502, message, internalError);
180
+ constructor(message = "Bad Gateway", cause) {
181
+ super(502, message, cause);
183
182
  }
184
183
  };
185
184
  var ServiceUnavailableError = class extends HttpError {
186
- constructor(message = "Service Unavailable", internalError) {
187
- super(503, message, internalError);
185
+ constructor(message = "Service Unavailable", cause) {
186
+ super(503, message, cause);
188
187
  }
189
188
  };
190
189
  var GatewayTimeoutError = class extends HttpError {
191
- constructor(message = "Gateway Timeout", internalError) {
192
- super(504, message, internalError);
190
+ constructor(message = "Gateway Timeout", cause) {
191
+ super(504, message, cause);
193
192
  }
194
193
  };
195
194
  var HTTPVersionNotSupportedError = class extends HttpError {
196
- constructor(message = "HTTP Version Not Supported", internalError) {
197
- super(505, message, internalError);
195
+ constructor(message = "HTTP Version Not Supported", cause) {
196
+ super(505, message, cause);
198
197
  }
199
198
  };
200
199
  var VariantAlsoNegotiatesError = class extends HttpError {
201
- constructor(message = "Variant Also Negotiates", internalError) {
202
- super(506, message, internalError);
200
+ constructor(message = "Variant Also Negotiates", cause) {
201
+ super(506, message, cause);
203
202
  }
204
203
  };
205
204
  var InsufficientStorageError = class extends HttpError {
206
- constructor(message = "Insufficient Storage", internalError) {
207
- super(507, message, internalError);
205
+ constructor(message = "Insufficient Storage", cause) {
206
+ super(507, message, cause);
208
207
  }
209
208
  };
210
209
  var LoopDetectedError = class extends HttpError {
211
- constructor(message = "Loop Detected", internalError) {
212
- super(508, message, internalError);
210
+ constructor(message = "Loop Detected", cause) {
211
+ super(508, message, cause);
213
212
  }
214
213
  };
215
214
  var NotExtendedError = class extends HttpError {
216
- constructor(message = "Not Extended", internalError) {
217
- super(510, message, internalError);
215
+ constructor(message = "Not Extended", cause) {
216
+ super(510, message, cause);
218
217
  }
219
218
  };
220
219
  var NetworkAuthenticationRequiredError = class extends HttpError {
221
- constructor(message = "Network Authentication Required", internalError) {
222
- super(511, message, internalError);
220
+ constructor(message = "Network Authentication Required", cause) {
221
+ super(511, message, cause);
223
222
  }
224
223
  };
225
- var createHttpError = (statusCode, message, internalError) => {
224
+ var createHttpError = (statusCode, message, cause) => {
226
225
  switch (statusCode) {
227
226
  case 400:
228
- return new BadRequestError(message, internalError);
227
+ return new BadRequestError(message, cause);
229
228
  case 401:
230
- return new UnauthorizedError(message, internalError);
229
+ return new UnauthorizedError(message, cause);
231
230
  case 402:
232
- return new PaymentRequiredError(message, internalError);
231
+ return new PaymentRequiredError(message, cause);
233
232
  case 403:
234
- return new ForbiddenError(message, internalError);
233
+ return new ForbiddenError(message, cause);
235
234
  case 404:
236
- return new NotFoundError(message, internalError);
235
+ return new NotFoundError(message, cause);
237
236
  case 405:
238
- return new MethodNotAllowedError(message, internalError);
237
+ return new MethodNotAllowedError(message, cause);
239
238
  case 406:
240
- return new NotAcceptableError(message, internalError);
239
+ return new NotAcceptableError(message, cause);
241
240
  case 407:
242
- return new ProxyAuthenticationRequiredError(message, internalError);
241
+ return new ProxyAuthenticationRequiredError(message, cause);
243
242
  case 408:
244
- return new RequestTimeoutError(message, internalError);
243
+ return new RequestTimeoutError(message, cause);
245
244
  case 409:
246
- return new ConflictError(message, internalError);
245
+ return new ConflictError(message, cause);
247
246
  case 410:
248
- return new GoneError(message, internalError);
247
+ return new GoneError(message, cause);
249
248
  case 411:
250
- return new LengthRequiredError(message, internalError);
249
+ return new LengthRequiredError(message, cause);
251
250
  case 412:
252
- return new PreconditionFailedError(message, internalError);
251
+ return new PreconditionFailedError(message, cause);
253
252
  case 413:
254
- return new PayloadTooLargeError(message, internalError);
253
+ return new PayloadTooLargeError(message, cause);
255
254
  case 414:
256
- return new URITooLongError(message, internalError);
255
+ return new URITooLongError(message, cause);
257
256
  case 415:
258
- return new UnsupportedMediaTypeError(message, internalError);
257
+ return new UnsupportedMediaTypeError(message, cause);
259
258
  case 416:
260
- return new RangeNotSatisfiableError(message, internalError);
259
+ return new RangeNotSatisfiableError(message, cause);
261
260
  case 417:
262
- return new ExpectationFailedError(message, internalError);
261
+ return new ExpectationFailedError(message, cause);
263
262
  case 418:
264
- return new IMATeapotError(message, internalError);
263
+ return new IMATeapotError(message, cause);
265
264
  case 421:
266
- return new MisdirectedRequestError(message, internalError);
265
+ return new MisdirectedRequestError(message, cause);
267
266
  case 422:
268
- return new UnprocessableEntityError(message, internalError);
267
+ return new UnprocessableEntityError(message, cause);
269
268
  case 423:
270
- return new LockedError(message, internalError);
269
+ return new LockedError(message, cause);
271
270
  case 424:
272
- return new FailedDependencyError(message, internalError);
271
+ return new FailedDependencyError(message, cause);
273
272
  case 425:
274
- return new TooEarlyError(message, internalError);
273
+ return new TooEarlyError(message, cause);
275
274
  case 426:
276
- return new UpgradeRequiredError(message, internalError);
275
+ return new UpgradeRequiredError(message, cause);
277
276
  case 428:
278
- return new PreconditionRequiredError(message, internalError);
277
+ return new PreconditionRequiredError(message, cause);
279
278
  case 429:
280
- return new TooManyRequestsError(message, internalError);
279
+ return new TooManyRequestsError(message, cause);
281
280
  case 431:
282
- return new RequestHeaderFieldsTooLargeError(message, internalError);
281
+ return new RequestHeaderFieldsTooLargeError(message, cause);
283
282
  case 451:
284
- return new UnavailableForLegalReasonsError(message, internalError);
283
+ return new UnavailableForLegalReasonsError(message, cause);
285
284
  case 500:
286
- return new InternalServerError(message, internalError);
285
+ return new InternalServerError(message, cause);
287
286
  case 501:
288
- return new NotImplementedError(message, internalError);
287
+ return new NotImplementedError(message, cause);
289
288
  case 502:
290
- return new BadGatewayError(message, internalError);
289
+ return new BadGatewayError(message, cause);
291
290
  case 503:
292
- return new ServiceUnavailableError(message, internalError);
291
+ return new ServiceUnavailableError(message, cause);
293
292
  case 504:
294
- return new GatewayTimeoutError(message, internalError);
293
+ return new GatewayTimeoutError(message, cause);
295
294
  case 505:
296
- return new HTTPVersionNotSupportedError(message, internalError);
295
+ return new HTTPVersionNotSupportedError(message, cause);
297
296
  case 506:
298
- return new VariantAlsoNegotiatesError(message, internalError);
297
+ return new VariantAlsoNegotiatesError(message, cause);
299
298
  case 507:
300
- return new InsufficientStorageError(message, internalError);
299
+ return new InsufficientStorageError(message, cause);
301
300
  case 508:
302
- return new LoopDetectedError(message, internalError);
301
+ return new LoopDetectedError(message, cause);
303
302
  case 510:
304
- return new NotExtendedError(message, internalError);
303
+ return new NotExtendedError(message, cause);
305
304
  case 511:
306
- return new NetworkAuthenticationRequiredError(message, internalError);
305
+ return new NetworkAuthenticationRequiredError(message, cause);
307
306
  default:
308
- return new HttpError(statusCode, message ?? "Error");
307
+ return new HttpError(statusCode, message ?? "Error", cause);
309
308
  }
310
309
  };
311
310
  var fromAxiosError = (axiosError) => {
312
- var _a, _b;
313
- const statusCode = ((_a = axiosError.response) == null ? void 0 : _a.status) || 500;
314
- const message = ((_b = axiosError.response) == null ? void 0 : _b.statusText) || "Internal Server Error";
315
- const internalError = new Error(axiosError.message);
316
- internalError.name = axiosError.name;
317
- internalError.stack = axiosError.stack;
318
- return createHttpError(statusCode, message, internalError);
311
+ const statusCode = axiosError.response?.status || 500;
312
+ const message = axiosError.response?.statusText || "Internal Server Error";
313
+ const cause = new Error(axiosError.message);
314
+ cause.name = axiosError.name;
315
+ cause.stack = axiosError.stack;
316
+ return createHttpError(statusCode, message, cause);
319
317
  };
320
318
  export {
321
319
  BadGatewayError,
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@sebspark/openapi-core",
3
- "version": "1.4.1",
3
+ "version": "1.5.0",
4
4
  "license": "Apache-2.0",
5
5
  "main": "dist/index.js",
6
6
  "module": "dist/index.mjs",
@@ -16,6 +16,7 @@
16
16
  "typecheck": "vitest --typecheck.only --passWithNoTests"
17
17
  },
18
18
  "devDependencies": {
19
+ "@types/node": "20.12.12",
19
20
  "tsconfig": "*"
20
21
  },
21
22
  "dependencies": {