Scope each request independently

packages/core/__tests__/index.js

@@ -144,24 +144,26 @@ describe('🛵  Middy test suite', () => {
       return callback(null, { foo: 'bar' })
     })
 
+    const executedBefore = []
+    const executedAfter = []
     const m1 = () => ({
       before: (handler, next) => {
-        handler.executedBefore = ['m1']
+        executedBefore.push('m1')
         next()
       },
       after: (handler, next) => {
-        handler.executedAfter.push('m1')
+        executedAfter.push('m1')
         next()
       }
     })
 
     const m2 = () => ({
       before: (handler, next) => {
-        handler.executedBefore.push('m2')
+        executedBefore.push('m2')
         next()
       },
       after: (handler, next) => {
-        handler.executedAfter = ['m2']
+        executedAfter.push('m2')
         next()
       }
     })
@@ -172,15 +174,17 @@ describe('🛵  Middy test suite', () => {
 
     // executes the handler
     handler({}, {}, (_, response) => {
-      expect(handler.executedBefore).toEqual(['m1', 'm2'])
-      expect(handler.executedAfter).toEqual(['m2', 'm1'])
+      expect(executedBefore).toEqual(['m1', 'm2'])
+      expect(executedAfter).toEqual(['m2', 'm1'])
       expect(response).toEqual({ foo: 'bar' })
       endTest()
     })
   })
 
   test('"before" middlewares should be able to change event', (endTest) => {
+    let handlerEvent
     const handler = middy((event, context, callback) => {
+      handlerEvent = event
       return callback(null, { foo: 'bar' })
     })
 
@@ -192,7 +196,7 @@ describe('🛵  Middy test suite', () => {
     handler.before(changeEventMiddleware)
 
     handler({}, {}, () => {
-      expect(handler.event.modified).toBe(true)
+      expect(handlerEvent.modified).toBe(true)
       endTest()
     })
   })
@@ -209,8 +213,9 @@ describe('🛵  Middy test suite', () => {
 
     handler.after(changeResponseMiddleware)
 
-    handler({}, {}, () => {
-      expect(handler.response.modified).toBe(true)
+    handler({}, {}, (err, response) => {
+      expect(err).toBeNull()
+      expect(response.modified).toBe(true)
       endTest()
     })
   })
@@ -604,13 +609,8 @@ describe('🛵  Middy test suite', () => {
   })
 
   test('It should handle async middlewares', (endTest) => {
-    const asyncBefore = async (handler) => {
-      handler.event.asyncBefore = true
-    }
-
-    const asyncAfter = async (handler) => {
-      handler.event.asyncAfter = true
-    }
+    const asyncBefore = jest.fn(async () => {})
+    const asyncAfter = jest.fn(async () => {})
 
     const handler = middy((event, context, callback) => {
       return callback(null, { some: 'response' })
@@ -622,8 +622,8 @@ describe('🛵  Middy test suite', () => {
 
     handler({}, {}, (err, response) => {
       expect(err).toBeNull()
-      expect(handler.event.asyncBefore).toBeTruthy()
-      expect(handler.event.asyncAfter).toBeTruthy()
+      expect(asyncBefore).toHaveBeenCalled()
+      expect(asyncAfter).toHaveBeenCalled()
       endTest()
     })
   })

packages/core/index.js

@@ -64,7 +64,7 @@ const once = require('once')
  * @property {middlewareFunction} onError - the middleware function to attach as *error* middleware
  */
 
-const runMiddlewares = (middlewares, instance, done) => {
+const runMiddlewares = (middlewares, request, done) => {
   const stack = Array.from(middlewares)
   const runNext = (err) => {
     try {
@@ -75,7 +75,7 @@ const runMiddlewares = (middlewares, instance, done) => {
       const nextMiddleware = stack.shift()
 
       if (nextMiddleware) {
-        const retVal = nextMiddleware(instance, runNext)
+        const retVal = nextMiddleware(request, runNext)
 
         if (retVal) {
           if (!isPromise(retVal)) {
@@ -99,19 +99,19 @@ const runMiddlewares = (middlewares, instance, done) => {
   runNext()
 }
 
-const runErrorMiddlewares = (middlewares, instance, done) => {
+const runErrorMiddlewares = (middlewares, request, done) => {
   const stack = Array.from(middlewares)
-  instance.__handledError = false
+  request.__handledError = false
   const runNext = (err) => {
     try {
       if (!err) {
-        instance.__handledError = true
+        request.__handledError = true
       }
 
       const nextMiddleware = stack.shift()
 
       if (nextMiddleware) {
-        const retVal = nextMiddleware(instance, runNext)
+        const retVal = nextMiddleware(request, runNext)
 
         if (retVal) {
           if (!isPromise(retVal)) {
@@ -129,13 +129,13 @@ const runErrorMiddlewares = (middlewares, instance, done) => {
         return
       }
 
-      return done(instance.__handledError ? null : err)
+      return done(request.__handledError ? null : err)
     } catch (err) {
       return done(err)
     }
   }
 
-  runNext(instance.error)
+  runNext(request.error)
 }
 
 /**
@@ -149,44 +149,45 @@ const middy = (handler) => {
   const errorMiddlewares = []
 
   const instance = (event, context, callback) => {
-    instance.event = event
-    instance.context = context
-    instance.callback = callback
-    instance.response = null
-    instance.error = null
+    const request = {}
+    request.event = event
+    request.context = context
+    request.callback = callback
+    request.response = null
+    request.error = null
 
     const middyPromise = new Promise((resolve, reject) => {
       const terminate = (err) => {
         if (err) {
           return callback ? callback(err) : reject(err)
         }
 
-        return callback ? callback(null, instance.response) : resolve(instance.response)
+        return callback ? callback(null, request.response) : resolve(request.response)
       }
 
       const errorHandler = err => {
-        instance.error = err
-        return runErrorMiddlewares(errorMiddlewares, instance, terminate)
+        request.error = err
+        return runErrorMiddlewares(errorMiddlewares, request, terminate)
       }
 
-      runMiddlewares(beforeMiddlewares, instance, (err) => {
+      runMiddlewares(beforeMiddlewares, request, (err) => {
         if (err) return errorHandler(err)
 
         const onHandlerError = once((err) => {
-          instance.response = null
+          request.response = null
           errorHandler(err)
         })
 
         const onHandlerSuccess = once((response) => {
-          instance.response = response
-          runMiddlewares(afterMiddlewares, instance, (err) => {
+          request.response = response
+          runMiddlewares(afterMiddlewares, request, (err) => {
             if (err) return errorHandler(err)
 
             terminate()
           })
         })
 
-        const handlerReturnValue = handler.call(instance, instance.event, context, (err, response) => {
+        const handlerReturnValue = handler.call(request, request.event, context, (err, response) => {
           if (err) return onHandlerError(err)
           onHandlerSuccess(response)
         })
@@ -203,7 +204,7 @@ const middy = (handler) => {
         }
       })
     })
-    if (!instance.callback) return middyPromise
+    if (!request.callback) return middyPromise
   }
 
   instance.use = (middlewares) => {