[INTERNAL] Refactor middlewareRepository to include specVersion

Pass new middlewareUtil instance to custom middleware defining spec
version 2.0 or higher

Author: RandomByte

lib/middleware/MiddlewareManager.js

@@ -36,9 +36,12 @@ class MiddlewareManager {
 		wrapperCallback, mountPath = "/",
 		beforeMiddleware, afterMiddleware
 	} = {}) {
-		let middlewareCallback = middlewareRepository.getMiddleware(configuredMiddlewareName);
+		const middlewareInfo = middlewareRepository.getMiddleware(configuredMiddlewareName);
+		let middlewareCallback;
 		if (wrapperCallback) {
-			middlewareCallback = wrapperCallback(middlewareCallback);
+			middlewareCallback = wrapperCallback(middlewareInfo);
+		} else {
+			middlewareCallback = middlewareInfo.middleware;
 		}
 
 		let middlewareName = configuredMiddlewareName;
@@ -82,7 +85,7 @@ class MiddlewareManager {
 
 	async addStandardMiddleware() {
 		await this.addMiddleware("csp", {
-			wrapperCallback: (cspModule) => {
+			wrapperCallback: ({middleware: cspModule}) => {
 				const oCspConfig = {
 					allowDynamicPolicySelection: true,
 					allowDynamicPolicyDefinition: true,
@@ -130,7 +133,7 @@ class MiddlewareManager {
 		await this.addMiddleware("serveThemes");
 		await this.addMiddleware("versionInfo", {
 			mountPath: "/resources/sap-ui-version.json",
-			wrapperCallback: (versionInfoModule) => {
+			wrapperCallback: ({middleware: versionInfoModule}) => {
 				return ({resources, middlewareUtil}) => {
 					return versionInfoModule({
 						resources,
@@ -147,7 +150,7 @@ class MiddlewareManager {
 		//	as it will reject them with a 405 (Method not allowed) instead of 404 like our old tooling
 		await this.addMiddleware("nonReadRequests");
 		await this.addMiddleware("serveIndex", {
-			wrapperCallback: (middleware) => {
+			wrapperCallback: ({middleware: middleware}) => {
 				return ({resources, middlewareUtil}) => middleware({
 					resources,
 					middlewareUtil,
@@ -182,15 +185,17 @@ class MiddlewareManager {
 			}
 
 			await this.addMiddleware(middlewareDef.name, {
-				wrapperCallback: (middleware) => {
+				wrapperCallback: ({middleware: middleware, specVersion}) => {
 					return ({resources, middlewareUtil}) => {
 						const options = {
 							configuration: middlewareDef.configuration
 						};
-						// TODO: Pass "middlewareUtil" only to custom middleware with specVersion >=2.0
-						//	Requires middleware-/task-repository enhancement
-						//	Use middlewareUtil.getInterface(specVersion)
-						return middleware({resources, options});
+						const params = {resources, options};
+						if (specVersion === "2.0") {
+							// Supply interface to MiddlewareUtil instance starting with specVersion 2.0
+							params.middlewareUtil = middlewareUtil.getInterface(specVersion);
+						}
+						return middleware(params);
 					};
 				},
 				mountPath: middlewareDef.mountPath,

lib/middleware/middlewareRepository.js

@@ -1,31 +1,37 @@
 const middlewares = {
-	compression: "compression",
-	cors: "cors",
-	csp: "./csp",
-	serveResources: "./serveResources",
-	serveIndex: "./serveIndex",
-	discovery: "./discovery",
-	versionInfo: "./versionInfo",
-	connectUi5Proxy: "./connectUi5Proxy",
-	serveThemes: "./serveThemes",
-	testRunner: "./testRunner",
-	nonReadRequests: "./nonReadRequests"
+	compression: {path: "compression"},
+	cors: {path: "cors"},
+	csp: {path: "./csp"},
+	serveResources: {path: "./serveResources"},
+	serveIndex: {path: "./serveIndex"},
+	discovery: {path: "./discovery"},
+	versionInfo: {path: "./versionInfo"},
+	connectUi5Proxy: {path: "./connectUi5Proxy"},
+	serveThemes: {path: "./serveThemes"},
+	testRunner: {path: "./testRunner"},
+	nonReadRequests: {path: "./nonReadRequests"}
 };
 
 function getMiddleware(middlewareName) {
-	const middlewarePath = middlewares[middlewareName];
+	const middlewareInfo = middlewares[middlewareName];
 
-	if (!middlewarePath) {
+	if (!middlewareInfo) {
 		throw new Error(`middlewareRepository: Unknown Middleware ${middlewareName}`);
 	}
-	return require(middlewarePath);
+	return {
+		middleware: require(middlewareInfo.path),
+		specVersion: middlewareInfo.specVersion
+	};
 }
 
-function addMiddleware(name, middlewarePath) {
+function addMiddleware({name, specVersion, middlewarePath}) {
 	if (middlewares[name]) {
-		throw new Error(`middlewareRepository: Middleware ${name} already registered`);
+		throw new Error(`middlewareRepository: A middleware with the name ${name} has already been registered`);
 	}
-	middlewares[name] = middlewarePath;
+	middlewares[name] = {
+		path: middlewarePath,
+		specVersion
+	};
 }
 
 module.exports = {

test/lib/server/middleware/MiddlewareManager.js

@@ -222,15 +222,16 @@ test("addMiddleware: Add middleware with rapperCallback parameter", async (t) =>
 			dependencies: "ponies"
 		}
 	});
-	const serveIndexModule = middlewareRepository.getMiddleware("serveIndex");
+	const serveIndexMiddlewareInfo = middlewareRepository.getMiddleware("serveIndex");
 
 	const moduleStub = sinon.stub().returns("🍅");
 	const wrapperCallbackStub = sinon.stub().returns(moduleStub);
 	await middlewareManager.addMiddleware("serveIndex", { // Add middleware to test for
 		wrapperCallback: wrapperCallbackStub
 	});
 	t.deepEqual(wrapperCallbackStub.callCount, 1, "Wrapper callback got called once");
-	t.is(wrapperCallbackStub.getCall(0).args[0], serveIndexModule, "Wrapper callback got called with correct module");
+	t.deepEqual(wrapperCallbackStub.getCall(0).args[0], serveIndexMiddlewareInfo,
+		"Wrapper callback got called with correct module");
 	t.deepEqual(moduleStub.callCount, 1, "Wrapper callback got called once");
 	t.deepEqual(moduleStub.getCall(0).args[0].resources, {
 		all: "I",
@@ -514,11 +515,20 @@ test("addCustomMiddleware: wrapperCallback", async (t) => {
 
 	const wrapperCallback = addMiddlewareStub.getCall(0).args[1].wrapperCallback;
 	const middlewareModuleStub = sinon.stub().returns("ok");
-	const middlewareWrapper = wrapperCallback(middlewareModuleStub);
+	const middlewareModuleInfo = {
+		middleware: middlewareModuleStub,
+		specVersion: "1.1"
+	};
+	const middlewareWrapper = wrapperCallback(middlewareModuleInfo);
+	const middlewareUtil = {
+		getInterface: sinon.stub().returns("interfacedMiddlewareUtil")
+	};
 	const res = middlewareWrapper({
-		resources: "resources"
+		resources: "resources",
+		middlewareUtil
 	});
 	t.deepEqual(res, "ok", "Wrapper callback returned expected value");
+	t.is(middlewareUtil.getInterface.callCount, 0, "middlewareUtil.getInterface has not been called");
 	t.deepEqual(middlewareModuleStub.callCount, 1, "Middleware module got called once");
 	t.deepEqual(middlewareModuleStub.getCall(0).args[0], {
 		resources: "resources",
@@ -529,3 +539,62 @@ test("addCustomMiddleware: wrapperCallback", async (t) => {
 		}
 	}, "Middleware module got called with correct arguments");
 });
+
+test("addCustomMiddleware: wrapperCallback provides middlewareUtil to custom middleware", async (t) => {
+	const project = {
+		metadata: {
+			name: "my project"
+		},
+		server: {
+			customMiddleware: [{
+				name: "my custom middleware A",
+				beforeMiddleware: "cors",
+				configuration: {
+					"🦊": "🐰"
+				}
+			}]
+		}
+	};
+	const middlewareManager = new MiddlewareManager({
+		tree: project,
+		resources: {
+			all: "I",
+			rootProject: "like",
+			dependencies: "ponies"
+		}
+	});
+	const addMiddlewareStub = sinon.stub(middlewareManager, "addMiddleware").resolves();
+	await middlewareManager.addCustomMiddleware();
+
+	t.deepEqual(addMiddlewareStub.callCount, 1, "addMiddleware was called once");
+
+	const wrapperCallback = addMiddlewareStub.getCall(0).args[1].wrapperCallback;
+	const middlewareModuleStub = sinon.stub().returns("ok");
+	const middlewareModuleInfo = {
+		middleware: middlewareModuleStub,
+		specVersion: "2.0"
+	};
+	const middlewareWrapper = wrapperCallback(middlewareModuleInfo);
+	const middlewareUtil = {
+		getInterface: sinon.stub().returns("interfacedMiddlewareUtil")
+	};
+	const res = middlewareWrapper({
+		resources: "resources",
+		middlewareUtil
+	});
+
+	t.deepEqual(res, "ok", "Wrapper callback returned expected value");
+	t.is(middlewareUtil.getInterface.callCount, 1, "middlewareUtil.getInterface got called once");
+	t.deepEqual(middlewareUtil.getInterface.getCall(0).args[0], "2.0",
+		"middlewareUtil.getInterface got called correct arguments");
+	t.deepEqual(middlewareModuleStub.callCount, 1, "Middleware module got called once");
+	t.deepEqual(middlewareModuleStub.getCall(0).args[0], {
+		resources: "resources",
+		options: {
+			configuration: {
+				"🦊": "🐰"
+			}
+		},
+		middlewareUtil: "interfacedMiddlewareUtil"
+	}, "Middleware module got called with correct arguments");
+});

test/lib/server/middleware/middlewareRepository.js

@@ -1,10 +1,14 @@
 const test = require("ava");
+const path = require("path");
 const middlewareRepository = require("../../../../lib/middleware/middlewareRepository");
 
 test("getMiddleware", async (t) => {
 	const cspModule = require("../../../../lib/middleware/csp");
 	const res = middlewareRepository.getMiddleware("csp");
-	t.is(res, cspModule, "Returned correct middleware module");
+	t.deepEqual(res, {
+		middleware: cspModule,
+		specVersion: undefined
+	}, "Returned correct middleware module");
 });
 
 test("getMiddleware: Unknown middleware", async (t) => {
@@ -16,17 +20,27 @@ test("getMiddleware: Unknown middleware", async (t) => {
 });
 
 test("addMiddleware", async (t) => {
-	const cspModule = require("../../../../lib/middleware/csp");
-	middlewareRepository.addMiddleware("🐠", "./csp");
+	const cspModulePath = path.posix.join(__dirname, "..", "..", "..", "..", "lib", "middleware", "csp");
+	middlewareRepository.addMiddleware({
+		name: "🐠",
+		specVersion: "2.0",
+		middlewarePath: cspModulePath
+	});
 	const res = middlewareRepository.getMiddleware("🐠");
 
-	t.is(res, cspModule, "Returned added middleware module");
+	t.deepEqual(res, {
+		middleware: require(cspModulePath),
+		specVersion: "2.0",
+	}, "Returned correct middleware module");
 });
 
 test("addMiddleware: Duplicate middleware", async (t) => {
 	const err = t.throws(() => {
-		middlewareRepository.addMiddleware("cors");
+		middlewareRepository.addMiddleware({
+			name: "cors"
+		});
 	});
-	t.deepEqual(err.message, "middlewareRepository: Middleware cors already registered",
+	t.deepEqual(err.message,
+		"middlewareRepository: A middleware with the name cors has already been registered",
 		"Threw error with correct message");
 });