Merge pull request #113 from jvandervelden/jvandervelden/handle-multi-next

Handle multiple calls to next()

Author: AntonBazhal

lib/handler.js

@@ -1,40 +1,38 @@
 'use strict';
 
-async function dispatch(middleware, state, i = 0) {
+async function dispatch(middleware, event, context, i = 0) {
 	const fn = middleware[i] || Function.prototype;
-	const next = async (err, context, event) => {
+	let prevResult;
+	const next = async (err, nxtContext, nxtEvent) => {
 		if (err) {
 			throw err;
 		}
 
-		if (context !== undefined && context !== null) {
-			state.context = context;
-		}
+		const result = await dispatch(middleware, nxtEvent || event, nxtContext || context, i + 1);
 
-		if (event !== undefined && event !== null) {
-			state.event = event;
+		// Save result if one was passed
+		if (result !== undefined) {
+			prevResult = result;
 		}
 
-		await dispatch(middleware, state, i + 1);
-
-		return state.result;
+		return result;
 	};
 
-	const result = await fn(state.event, state.context, next);
+	const result = await fn(event, context, next);
 
-	if (result !== undefined) {
-		state.result = result;
+	// Use result from previous middleware if this one didn't pass back a result
+	if (result === undefined) {
+		return prevResult;
 	}
 
-	return state;
+	return result;
 }
 
 module.exports = function () {
 	const middleware = [];
 
 	const handler = async (event, context) => {
-		const { result } = await dispatch(middleware, { event, context });
-		return result;
+		return dispatch(middleware, event, context);
 	};
 
 	handler.use = mw => {

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@alpha-lambda/handler",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Middleware pipeline for AWS Lambda handlers",
   "repository": {
     "type": "git",

package.json

@@ -346,6 +346,34 @@ describe('handler', function() {
 				});
 		});
 
+		it('next() called with no more middleware, return undefined', function() {
+			const result = { foo: 'foo' };
+
+			const fixture = lambdaHandler()
+				.use((event, context, next) => next(null, context, result));
+
+			return fixture(testEvent, testContext)
+				.then(nextResult => {
+					expect(nextResult).to.be.undefined;
+				});
+		});
+
+		it('next() called with no more middleware, return last returned result', function() {
+			const result = { foo: 'foo' };
+
+			const fixture = lambdaHandler()
+				.use(async (event, context, next) => {
+					await next();
+					return result;
+				})
+				.use((event, context, next) => next());
+
+			return fixture(testEvent, testContext)
+				.then(nextResult => {
+					expect(nextResult).to.equal(result);
+				});
+		});
+
 		it('next() call is resolved with result value when it is overridden after calling chained next', function() {
 			const result1 = { foo: 'foo' };
 			const result2 = { bar: 'bar' };
@@ -367,6 +395,30 @@ describe('handler', function() {
 				});
 		});
 
+		it('next() can be called multiple times and result is handled', function() {
+			const multiEvent = ['f', 'b'];
+			const resultMap = {
+				f: { foo: 'foo' },
+				b: { bar: 'bar' }
+			};
+
+			const fixture = lambdaHandler()
+				.use(async (events, context, next) => {
+					return Promise.all(events.map(event => next(null, context, event)));
+				})
+				.use(async (event, context, next) => {
+					await next();
+				})
+				.use(async event => {
+					return resultMap[event];
+				});
+
+			return fixture(multiEvent, testContext)
+				.then(result => {
+					expect(result).to.deep.equal([resultMap.f, resultMap.b]);
+				});
+		});
+
 		it('has expected execution order', function() {
 			const order = [];
 			const fixture = lambdaHandler()