@middy/core 3.0.3 → 3.0.4
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.
- package/index.cjs +203 -1
- package/index.js +197 -1
- package/package.json +2 -2
package/index.cjs
CHANGED
|
@@ -1,3 +1,205 @@
|
|
|
1
|
-
"use strict";
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", {
|
|
3
|
+
value: true
|
|
4
|
+
});
|
|
5
|
+
module.exports = void 0;
|
|
6
|
+
var _events = require("events");
|
|
7
|
+
const defaultLambdaHandler = ()=>{};
|
|
8
|
+
const defaultPlugin = {
|
|
9
|
+
timeoutEarlyInMillis: 5,
|
|
10
|
+
timeoutEarlyResponse: ()=>{
|
|
11
|
+
throw new Error('Timeout');
|
|
12
|
+
}
|
|
13
|
+
};
|
|
14
|
+
const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
|
|
15
|
+
if (typeof lambdaHandler !== 'function') {
|
|
16
|
+
plugin = lambdaHandler;
|
|
17
|
+
lambdaHandler = defaultLambdaHandler;
|
|
18
|
+
}
|
|
19
|
+
plugin = {
|
|
20
|
+
...defaultPlugin,
|
|
21
|
+
...plugin
|
|
22
|
+
};
|
|
23
|
+
plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0;
|
|
24
|
+
plugin.beforePrefetch?.();
|
|
25
|
+
const beforeMiddlewares = [];
|
|
26
|
+
const afterMiddlewares = [];
|
|
27
|
+
const onErrorMiddlewares = [];
|
|
28
|
+
const middy1 = (event = {}, context = {})=>{
|
|
29
|
+
plugin.requestStart?.();
|
|
30
|
+
const request = {
|
|
31
|
+
event,
|
|
32
|
+
context,
|
|
33
|
+
response: undefined,
|
|
34
|
+
error: undefined,
|
|
35
|
+
internal: plugin.internal ?? {}
|
|
36
|
+
};
|
|
37
|
+
return runRequest(request, [
|
|
38
|
+
...beforeMiddlewares
|
|
39
|
+
], lambdaHandler, [
|
|
40
|
+
...afterMiddlewares
|
|
41
|
+
], [
|
|
42
|
+
...onErrorMiddlewares
|
|
43
|
+
], plugin);
|
|
44
|
+
};
|
|
45
|
+
middy1.use = (middlewares)=>{
|
|
46
|
+
if (!Array.isArray(middlewares)) {
|
|
47
|
+
middlewares = [
|
|
48
|
+
middlewares
|
|
49
|
+
];
|
|
50
|
+
}
|
|
51
|
+
for (const middleware of middlewares){
|
|
52
|
+
const { before , after , onError } = middleware;
|
|
53
|
+
if (!before && !after && !onError) {
|
|
54
|
+
throw new Error('Middleware must be an object containing at least one key among "before", "after", "onError"');
|
|
55
|
+
}
|
|
56
|
+
if (before) middy1.before(before);
|
|
57
|
+
if (after) middy1.after(after);
|
|
58
|
+
if (onError) middy1.onError(onError);
|
|
59
|
+
}
|
|
60
|
+
return middy1;
|
|
61
|
+
};
|
|
62
|
+
middy1.before = (beforeMiddleware)=>{
|
|
63
|
+
beforeMiddlewares.push(beforeMiddleware);
|
|
64
|
+
return middy1;
|
|
65
|
+
};
|
|
66
|
+
middy1.after = (afterMiddleware)=>{
|
|
67
|
+
afterMiddlewares.unshift(afterMiddleware);
|
|
68
|
+
return middy1;
|
|
69
|
+
};
|
|
70
|
+
middy1.onError = (onErrorMiddleware)=>{
|
|
71
|
+
onErrorMiddlewares.unshift(onErrorMiddleware);
|
|
72
|
+
return middy1;
|
|
73
|
+
};
|
|
74
|
+
middy1.handler = (replaceLambdaHandler)=>{
|
|
75
|
+
lambdaHandler = replaceLambdaHandler;
|
|
76
|
+
return middy1;
|
|
77
|
+
};
|
|
78
|
+
return middy1;
|
|
79
|
+
};
|
|
80
|
+
const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin)=>{
|
|
81
|
+
const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis;
|
|
82
|
+
try {
|
|
83
|
+
await runMiddlewares(request, beforeMiddlewares, plugin);
|
|
84
|
+
if (request.response === undefined) {
|
|
85
|
+
plugin.beforeHandler?.();
|
|
86
|
+
const handlerAbort = new AbortController();
|
|
87
|
+
let timeoutAbort;
|
|
88
|
+
if (timeoutEarly) timeoutAbort = new AbortController();
|
|
89
|
+
request.response = await Promise.race([
|
|
90
|
+
lambdaHandler(request.event, request.context, {
|
|
91
|
+
signal: handlerAbort.signal
|
|
92
|
+
}),
|
|
93
|
+
timeoutEarly ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, {
|
|
94
|
+
signal: timeoutAbort.signal
|
|
95
|
+
}).then(()=>{
|
|
96
|
+
handlerAbort.abort();
|
|
97
|
+
return plugin.timeoutEarlyResponse();
|
|
98
|
+
}) : Promise.race([])
|
|
99
|
+
]);
|
|
100
|
+
if (timeoutEarly) timeoutAbort.abort();
|
|
101
|
+
plugin.afterHandler?.();
|
|
102
|
+
await runMiddlewares(request, afterMiddlewares, plugin);
|
|
103
|
+
}
|
|
104
|
+
} catch (e) {
|
|
105
|
+
request.response = undefined;
|
|
106
|
+
request.error = e;
|
|
107
|
+
try {
|
|
108
|
+
await runMiddlewares(request, onErrorMiddlewares, plugin);
|
|
109
|
+
} catch (e) {
|
|
110
|
+
e.originalError = request.error;
|
|
111
|
+
request.error = e;
|
|
112
|
+
throw request.error;
|
|
113
|
+
}
|
|
114
|
+
if (request.response === undefined) throw request.error;
|
|
115
|
+
} finally{
|
|
116
|
+
await plugin.requestEnd?.(request);
|
|
117
|
+
}
|
|
118
|
+
return request.response;
|
|
119
|
+
};
|
|
120
|
+
const runMiddlewares = async (request, middlewares, plugin)=>{
|
|
121
|
+
for (const nextMiddleware of middlewares){
|
|
122
|
+
plugin.beforeMiddleware?.(nextMiddleware.name);
|
|
123
|
+
const res = await nextMiddleware(request);
|
|
124
|
+
plugin.afterMiddleware?.(nextMiddleware.name);
|
|
125
|
+
if (res !== undefined) {
|
|
126
|
+
request.response = res;
|
|
127
|
+
return;
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
};
|
|
131
|
+
const polyfillAbortController = ()=>{
|
|
132
|
+
if (process.version < 'v15.0.0') {
|
|
133
|
+
class AbortSignal {
|
|
134
|
+
toString() {
|
|
135
|
+
return '[object AbortSignal]';
|
|
136
|
+
}
|
|
137
|
+
get [Symbol.toStringTag]() {
|
|
138
|
+
return 'AbortSignal';
|
|
139
|
+
}
|
|
140
|
+
removeEventListener(name, handler) {
|
|
141
|
+
this.eventEmitter.removeListener(name, handler);
|
|
142
|
+
}
|
|
143
|
+
addEventListener(name, handler) {
|
|
144
|
+
this.eventEmitter.on(name, handler);
|
|
145
|
+
}
|
|
146
|
+
dispatchEvent(type) {
|
|
147
|
+
const event = {
|
|
148
|
+
type,
|
|
149
|
+
target: this
|
|
150
|
+
};
|
|
151
|
+
const handlerName = `on${type}`;
|
|
152
|
+
if (typeof this[handlerName] === 'function') this[handlerName](event);
|
|
153
|
+
this.eventEmitter.emit(type, event);
|
|
154
|
+
}
|
|
155
|
+
constructor(){
|
|
156
|
+
this.eventEmitter = new _events.EventEmitter();
|
|
157
|
+
this.onabort = null;
|
|
158
|
+
this.aborted = false;
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
return class AbortController {
|
|
162
|
+
abort() {
|
|
163
|
+
if (this.signal.aborted) return;
|
|
164
|
+
this.signal.aborted = true;
|
|
165
|
+
this.signal.dispatchEvent('abort');
|
|
166
|
+
}
|
|
167
|
+
toString() {
|
|
168
|
+
return '[object AbortController]';
|
|
169
|
+
}
|
|
170
|
+
get [Symbol.toStringTag]() {
|
|
171
|
+
return 'AbortController';
|
|
172
|
+
}
|
|
173
|
+
constructor(){
|
|
174
|
+
this.signal = new AbortSignal();
|
|
175
|
+
}
|
|
176
|
+
};
|
|
177
|
+
} else {
|
|
178
|
+
return AbortController;
|
|
179
|
+
}
|
|
180
|
+
};
|
|
181
|
+
global.AbortController = polyfillAbortController();
|
|
182
|
+
const polyfillSetTimeoutPromise = ()=>{
|
|
183
|
+
return (ms, { signal })=>{
|
|
184
|
+
if (signal.aborted) {
|
|
185
|
+
return Promise.reject(new Error('Aborted', 'AbortError'));
|
|
186
|
+
}
|
|
187
|
+
return new Promise((resolve, reject)=>{
|
|
188
|
+
const abortHandler = ()=>{
|
|
189
|
+
clearTimeout(timeout);
|
|
190
|
+
reject(new Error('Aborted', 'AbortError'));
|
|
191
|
+
};
|
|
192
|
+
const timeout = setTimeout(()=>{
|
|
193
|
+
resolve();
|
|
194
|
+
signal.removeEventListener('abort', abortHandler);
|
|
195
|
+
}, ms);
|
|
196
|
+
signal.addEventListener('abort', abortHandler);
|
|
197
|
+
});
|
|
198
|
+
};
|
|
199
|
+
};
|
|
200
|
+
const setTimeoutPromise = polyfillSetTimeoutPromise();
|
|
201
|
+
var _default = middy;
|
|
202
|
+
module.exports = _default;
|
|
203
|
+
|
|
2
204
|
|
|
3
205
|
//# sourceMappingURL=index.cjs.map
|
package/index.js
CHANGED
|
@@ -1,3 +1,199 @@
|
|
|
1
|
-
import
|
|
1
|
+
import { EventEmitter } from 'events';
|
|
2
|
+
const defaultLambdaHandler = ()=>{};
|
|
3
|
+
const defaultPlugin = {
|
|
4
|
+
timeoutEarlyInMillis: 5,
|
|
5
|
+
timeoutEarlyResponse: ()=>{
|
|
6
|
+
throw new Error('Timeout');
|
|
7
|
+
}
|
|
8
|
+
};
|
|
9
|
+
const middy = (lambdaHandler = defaultLambdaHandler, plugin = {})=>{
|
|
10
|
+
if (typeof lambdaHandler !== 'function') {
|
|
11
|
+
plugin = lambdaHandler;
|
|
12
|
+
lambdaHandler = defaultLambdaHandler;
|
|
13
|
+
}
|
|
14
|
+
plugin = {
|
|
15
|
+
...defaultPlugin,
|
|
16
|
+
...plugin
|
|
17
|
+
};
|
|
18
|
+
plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0;
|
|
19
|
+
plugin.beforePrefetch?.();
|
|
20
|
+
const beforeMiddlewares = [];
|
|
21
|
+
const afterMiddlewares = [];
|
|
22
|
+
const onErrorMiddlewares = [];
|
|
23
|
+
const middy1 = (event = {}, context = {})=>{
|
|
24
|
+
plugin.requestStart?.();
|
|
25
|
+
const request = {
|
|
26
|
+
event,
|
|
27
|
+
context,
|
|
28
|
+
response: undefined,
|
|
29
|
+
error: undefined,
|
|
30
|
+
internal: plugin.internal ?? {}
|
|
31
|
+
};
|
|
32
|
+
return runRequest(request, [
|
|
33
|
+
...beforeMiddlewares
|
|
34
|
+
], lambdaHandler, [
|
|
35
|
+
...afterMiddlewares
|
|
36
|
+
], [
|
|
37
|
+
...onErrorMiddlewares
|
|
38
|
+
], plugin);
|
|
39
|
+
};
|
|
40
|
+
middy1.use = (middlewares)=>{
|
|
41
|
+
if (!Array.isArray(middlewares)) {
|
|
42
|
+
middlewares = [
|
|
43
|
+
middlewares
|
|
44
|
+
];
|
|
45
|
+
}
|
|
46
|
+
for (const middleware of middlewares){
|
|
47
|
+
const { before , after , onError } = middleware;
|
|
48
|
+
if (!before && !after && !onError) {
|
|
49
|
+
throw new Error('Middleware must be an object containing at least one key among "before", "after", "onError"');
|
|
50
|
+
}
|
|
51
|
+
if (before) middy1.before(before);
|
|
52
|
+
if (after) middy1.after(after);
|
|
53
|
+
if (onError) middy1.onError(onError);
|
|
54
|
+
}
|
|
55
|
+
return middy1;
|
|
56
|
+
};
|
|
57
|
+
middy1.before = (beforeMiddleware)=>{
|
|
58
|
+
beforeMiddlewares.push(beforeMiddleware);
|
|
59
|
+
return middy1;
|
|
60
|
+
};
|
|
61
|
+
middy1.after = (afterMiddleware)=>{
|
|
62
|
+
afterMiddlewares.unshift(afterMiddleware);
|
|
63
|
+
return middy1;
|
|
64
|
+
};
|
|
65
|
+
middy1.onError = (onErrorMiddleware)=>{
|
|
66
|
+
onErrorMiddlewares.unshift(onErrorMiddleware);
|
|
67
|
+
return middy1;
|
|
68
|
+
};
|
|
69
|
+
middy1.handler = (replaceLambdaHandler)=>{
|
|
70
|
+
lambdaHandler = replaceLambdaHandler;
|
|
71
|
+
return middy1;
|
|
72
|
+
};
|
|
73
|
+
return middy1;
|
|
74
|
+
};
|
|
75
|
+
const runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin)=>{
|
|
76
|
+
const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis;
|
|
77
|
+
try {
|
|
78
|
+
await runMiddlewares(request, beforeMiddlewares, plugin);
|
|
79
|
+
if (request.response === undefined) {
|
|
80
|
+
plugin.beforeHandler?.();
|
|
81
|
+
const handlerAbort = new AbortController();
|
|
82
|
+
let timeoutAbort;
|
|
83
|
+
if (timeoutEarly) timeoutAbort = new AbortController();
|
|
84
|
+
request.response = await Promise.race([
|
|
85
|
+
lambdaHandler(request.event, request.context, {
|
|
86
|
+
signal: handlerAbort.signal
|
|
87
|
+
}),
|
|
88
|
+
timeoutEarly ? setTimeoutPromise(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, {
|
|
89
|
+
signal: timeoutAbort.signal
|
|
90
|
+
}).then(()=>{
|
|
91
|
+
handlerAbort.abort();
|
|
92
|
+
return plugin.timeoutEarlyResponse();
|
|
93
|
+
}) : Promise.race([])
|
|
94
|
+
]);
|
|
95
|
+
if (timeoutEarly) timeoutAbort.abort();
|
|
96
|
+
plugin.afterHandler?.();
|
|
97
|
+
await runMiddlewares(request, afterMiddlewares, plugin);
|
|
98
|
+
}
|
|
99
|
+
} catch (e) {
|
|
100
|
+
request.response = undefined;
|
|
101
|
+
request.error = e;
|
|
102
|
+
try {
|
|
103
|
+
await runMiddlewares(request, onErrorMiddlewares, plugin);
|
|
104
|
+
} catch (e) {
|
|
105
|
+
e.originalError = request.error;
|
|
106
|
+
request.error = e;
|
|
107
|
+
throw request.error;
|
|
108
|
+
}
|
|
109
|
+
if (request.response === undefined) throw request.error;
|
|
110
|
+
} finally{
|
|
111
|
+
await plugin.requestEnd?.(request);
|
|
112
|
+
}
|
|
113
|
+
return request.response;
|
|
114
|
+
};
|
|
115
|
+
const runMiddlewares = async (request, middlewares, plugin)=>{
|
|
116
|
+
for (const nextMiddleware of middlewares){
|
|
117
|
+
plugin.beforeMiddleware?.(nextMiddleware.name);
|
|
118
|
+
const res = await nextMiddleware(request);
|
|
119
|
+
plugin.afterMiddleware?.(nextMiddleware.name);
|
|
120
|
+
if (res !== undefined) {
|
|
121
|
+
request.response = res;
|
|
122
|
+
return;
|
|
123
|
+
}
|
|
124
|
+
}
|
|
125
|
+
};
|
|
126
|
+
const polyfillAbortController = ()=>{
|
|
127
|
+
if (process.version < 'v15.0.0') {
|
|
128
|
+
class AbortSignal {
|
|
129
|
+
toString() {
|
|
130
|
+
return '[object AbortSignal]';
|
|
131
|
+
}
|
|
132
|
+
get [Symbol.toStringTag]() {
|
|
133
|
+
return 'AbortSignal';
|
|
134
|
+
}
|
|
135
|
+
removeEventListener(name, handler) {
|
|
136
|
+
this.eventEmitter.removeListener(name, handler);
|
|
137
|
+
}
|
|
138
|
+
addEventListener(name, handler) {
|
|
139
|
+
this.eventEmitter.on(name, handler);
|
|
140
|
+
}
|
|
141
|
+
dispatchEvent(type) {
|
|
142
|
+
const event = {
|
|
143
|
+
type,
|
|
144
|
+
target: this
|
|
145
|
+
};
|
|
146
|
+
const handlerName = `on${type}`;
|
|
147
|
+
if (typeof this[handlerName] === 'function') this[handlerName](event);
|
|
148
|
+
this.eventEmitter.emit(type, event);
|
|
149
|
+
}
|
|
150
|
+
constructor(){
|
|
151
|
+
this.eventEmitter = new EventEmitter();
|
|
152
|
+
this.onabort = null;
|
|
153
|
+
this.aborted = false;
|
|
154
|
+
}
|
|
155
|
+
}
|
|
156
|
+
return class AbortController {
|
|
157
|
+
abort() {
|
|
158
|
+
if (this.signal.aborted) return;
|
|
159
|
+
this.signal.aborted = true;
|
|
160
|
+
this.signal.dispatchEvent('abort');
|
|
161
|
+
}
|
|
162
|
+
toString() {
|
|
163
|
+
return '[object AbortController]';
|
|
164
|
+
}
|
|
165
|
+
get [Symbol.toStringTag]() {
|
|
166
|
+
return 'AbortController';
|
|
167
|
+
}
|
|
168
|
+
constructor(){
|
|
169
|
+
this.signal = new AbortSignal();
|
|
170
|
+
}
|
|
171
|
+
};
|
|
172
|
+
} else {
|
|
173
|
+
return AbortController;
|
|
174
|
+
}
|
|
175
|
+
};
|
|
176
|
+
global.AbortController = polyfillAbortController();
|
|
177
|
+
const polyfillSetTimeoutPromise = ()=>{
|
|
178
|
+
return (ms, { signal })=>{
|
|
179
|
+
if (signal.aborted) {
|
|
180
|
+
return Promise.reject(new Error('Aborted', 'AbortError'));
|
|
181
|
+
}
|
|
182
|
+
return new Promise((resolve, reject)=>{
|
|
183
|
+
const abortHandler = ()=>{
|
|
184
|
+
clearTimeout(timeout);
|
|
185
|
+
reject(new Error('Aborted', 'AbortError'));
|
|
186
|
+
};
|
|
187
|
+
const timeout = setTimeout(()=>{
|
|
188
|
+
resolve();
|
|
189
|
+
signal.removeEventListener('abort', abortHandler);
|
|
190
|
+
}, ms);
|
|
191
|
+
signal.addEventListener('abort', abortHandler);
|
|
192
|
+
});
|
|
193
|
+
};
|
|
194
|
+
};
|
|
195
|
+
const setTimeoutPromise = polyfillSetTimeoutPromise();
|
|
196
|
+
export default middy;
|
|
197
|
+
|
|
2
198
|
|
|
3
199
|
//# sourceMappingURL=index.js.map
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@middy/core",
|
|
3
|
-
"version": "3.0.
|
|
3
|
+
"version": "3.0.4",
|
|
4
4
|
"description": "🛵 The stylish Node.js middleware engine for AWS Lambda (core package)",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"engines": {
|
|
@@ -54,5 +54,5 @@
|
|
|
54
54
|
"@types/aws-lambda": "^8.10.76",
|
|
55
55
|
"@types/node": "^17.0.0"
|
|
56
56
|
},
|
|
57
|
-
"gitHead": "
|
|
57
|
+
"gitHead": "3e9bc83e791f943c71cd7003fc27f0a3692d83a1"
|
|
58
58
|
}
|