@sebspark/openapi-core 1.4.2 → 1.5.1

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