[FEATURE] Add MiddlewareUtil providing convenience functions to all middleware

In order to correctly handle requests with URIs containing escape
sequences like "%20" (=whitespace), middleware implementations need to
decode any escape sequences in incoming request. To make this easier a
new MiddlewareUtil class is added. Every MiddlewareManager creates one
instance of this class and provides it to every standard middleware.

Custom middleware receive an interface to this instance with a set of
methods restricted by the specification version of the custom middleware
extension. This is yet to be implemented in a follow-up change as the
middleware repository does not yet provide specification version
information.

Author: RandomByte

lib/middleware/MiddlewareManager.js

@@ -1,4 +1,5 @@
 const middlewareRepository = require("./middlewareRepository");
+const MiddlewareUtil = require("./MiddlewareUtil");
 
 /**
  *
@@ -18,6 +19,7 @@ class MiddlewareManager {
 
 		this.middleware = {};
 		this.middlewareExecutionOrder = [];
+		this.middlewareUtil = new MiddlewareUtil();
 	}
 
 	async applyMiddleware(app) {
@@ -70,7 +72,10 @@ class MiddlewareManager {
 		}
 
 		this.middleware[middlewareName] = {
-			middleware: await Promise.resolve(middlewareCallback({resources: this.resources})),
+			middleware: await Promise.resolve(middlewareCallback({
+				resources: this.resources,
+				middlewareUtil: this.middlewareUtil
+			})),
 			mountPath
 		};
 	}
@@ -126,9 +131,10 @@ class MiddlewareManager {
 		await this.addMiddleware("versionInfo", {
 			mountPath: "/resources/sap-ui-version.json",
 			wrapperCallback: (versionInfoModule) => {
-				return ({resources}) => {
+				return ({resources, middlewareUtil}) => {
 					return versionInfoModule({
 						resources,
+						middlewareUtil,
 						tree: this.tree
 					});
 				};
@@ -142,8 +148,9 @@ class MiddlewareManager {
 		await this.addMiddleware("nonReadRequests");
 		await this.addMiddleware("serveIndex", {
 			wrapperCallback: (middleware) => {
-				return ({resources}) => middleware({
+				return ({resources, middlewareUtil}) => middleware({
 					resources,
+					middlewareUtil,
 					simpleIndex: this.options.simpleIndex
 				});
 			}
@@ -176,10 +183,13 @@ class MiddlewareManager {
 
 			await this.addMiddleware(middlewareDef.name, {
 				wrapperCallback: (middleware) => {
-					return ({resources}) => {
+					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});
 					};
 				},

lib/middleware/MiddlewareUtil.js

@@ -0,0 +1,96 @@
+/**
+ * Convenience functions for UI5 Server middleware.
+ * An instance of this class is passed to every standard UI5 Server middleware.
+ * Custom middleware that define a specification version >= 2.0 will also receive an instance
+ * of this class as part of the parameters of their create-middleware function.
+ *
+ * The set of functions that can be accessed by a custom middleware depends on the specification
+ * version defined for the extension.
+ *
+ * @public
+ * @memberof module:@ui5/server.middleware
+ */
+class MiddlewareUtil {
+	/**
+	 * Get an interface to an instance of this class that only provides those functions
+	 * that are supported by the given custom middleware extension specification version.
+	 *
+	 * @param {string} specVersion Specification Version of custom middleware extension
+	 * @returns {object} An object with bound instance methods supported by the given specification version
+	 */
+	getInterface(specVersion) {
+		const baseInterface = {
+			getPathname: this.getPathname.bind(this),
+			getMimeInfo: this.getMimeInfo.bind(this)
+		};
+		switch (specVersion) {
+		case "0.1":
+		case "1.0":
+		case "1.1":
+			return undefined;
+		case "2.0":
+			return baseInterface;
+		default:
+			throw new Error(`MiddlewareUtil: Unknown or unsupported specification version ${specVersion}`);
+		}
+	}
+
+	/**
+	 * Returns the [pathname]{@link https://developer.mozilla.org/en-US/docs/Web/API/URL/pathname}
+	 * of a given request. Any escape sequences will be decoded.
+	 * </br></br>
+	 * This method is only available to custom middleware extensions defining
+	 * <b>specification version 2.0 and above</b>.
+	 *
+	 * @param {object} req Request object
+	 * @returns {string} [Pathname]{@link https://developer.mozilla.org/en-US/docs/Web/API/URL/pathname}
+	 * of the given request
+	 * @public
+	 */
+	getPathname(req) {
+		const parseurl = require("parseurl");
+		let {pathname} = parseurl(req);
+		pathname = decodeURIComponent(pathname);
+		return pathname;
+	}
+
+	/**
+	 * MIME Info
+	 *
+	 * @example
+	 * const mimeInfo = {
+	 * 	"type": "text/html",
+	 * 	"charset": "utf-8",
+	 * 	"contentType": "text/html; charset=utf-8"
+	 * };
+	 *
+	 * @public
+	 * @typedef {object} MimeInfo
+	 * @property {string} type Detected content-type for the given resource path
+	 * @property {string} charset Default charset for the detected content-type
+	 * @property {string} contentType Calculated content-type header value
+	 * @memberof module:@ui5/server.middleware.MiddlewareUtil
+	 */
+	/**
+	 * Returns MIME information derived from a given resource path.
+	 * </br></br>
+	 * This method is only available to custom middleware extensions defining
+	 * <b>specification version 2.0 and above</b>.
+	 *
+	 * @param {object} resourcePath
+	 * @returns {module:@ui5/server.middleware.MiddlewareUtil.MimeInfo}
+	 * @public
+	 */
+	getMimeInfo(resourcePath) {
+		const mime = require("mime-types");
+		const type = mime.lookup(resourcePath) || "application/octet-stream";
+		const charset = mime.charset(type);
+		return {
+			type,
+			charset,
+			contentType: type + (charset ? "; charset=" + charset : "")
+		};
+	}
+}
+
+module.exports = MiddlewareUtil;

lib/mime-util.js

@@ -0,0 +1,101 @@
+const test = require("ava");
+const sinon = require("sinon");
+const mock = require("mock-require");
+const MiddlewareUtil = require("../../../../lib/middleware/MiddlewareUtil");
+
+test.afterEach.always((t) => {
+	sinon.restore();
+	mock.stopAll();
+});
+
+test.serial("getPathname", async (t) => {
+	const middlewareUtil = new MiddlewareUtil();
+	const parseurlStub = sinon.stub().returns({pathname: "path%20name"});
+	mock("parseurl", parseurlStub);
+	const pathname = middlewareUtil.getPathname("req");
+
+	t.is(parseurlStub.callCount, 1, "parseurl got called once");
+	t.is(parseurlStub.getCall(0).args[0], "req", "parseurl got called with correct argument");
+	t.is(pathname, "path name", "Correct pathname returned");
+});
+
+test.serial("getMimeInfo", async (t) => {
+	const middlewareUtil = new MiddlewareUtil();
+	const mime = require("mime-types");
+	const lookupStub = sinon.stub(mime, "lookup").returns("mytype");
+	const charsetStub = sinon.stub(mime, "charset").returns("mycharset");
+
+	const mimeInfo = middlewareUtil.getMimeInfo("resourcePath");
+
+	t.is(lookupStub.callCount, 1, "mime.lookup got called once");
+	t.is(lookupStub.getCall(0).args[0], "resourcePath", "mime.lookup got called with correct argument");
+	t.is(charsetStub.callCount, 1, "mime.charset got called once");
+	t.is(charsetStub.getCall(0).args[0], "mytype", "mime.charset got called with correct argument");
+	t.deepEqual(mimeInfo, {
+		type: "mytype",
+		charset: "mycharset",
+		contentType: "mytype; charset=mycharset"
+	}, "Correct pathname returned");
+});
+
+test.serial("getMimeInfo: unknown type", async (t) => {
+	const middlewareUtil = new MiddlewareUtil();
+	const mime = require("mime-types");
+	const lookupStub = sinon.stub(mime, "lookup");
+	const charsetStub = sinon.stub(mime, "charset");
+
+	const mimeInfo = middlewareUtil.getMimeInfo("resourcePath");
+
+	t.is(lookupStub.callCount, 1, "mime.lookup got called once");
+	t.is(lookupStub.getCall(0).args[0], "resourcePath", "mime.lookup got called with correct argument");
+	t.is(charsetStub.callCount, 1, "mime.charset got called once");
+	t.is(charsetStub.getCall(0).args[0], "application/octet-stream", "mime.charset got called with correct argument");
+	t.deepEqual(mimeInfo, {
+		type: "application/octet-stream",
+		charset: undefined,
+		contentType: "application/octet-stream"
+	}, "Correct pathname returned");
+});
+
+test("getInterface: specVersion 1.0", async (t) => {
+	const middlewareUtil = new MiddlewareUtil();
+
+	const interfacedMiddlewareUtil = middlewareUtil.getInterface("1.0");
+
+	t.is(interfacedMiddlewareUtil, undefined, "no interface provided");
+});
+
+test("getInterface: specVersion 2.0", async (t) => {
+	const middlewareUtil = new MiddlewareUtil();
+
+	const interfacedMiddlewareUtil = middlewareUtil.getInterface("2.0");
+
+	t.deepEqual(Object.keys(interfacedMiddlewareUtil), [
+		"getPathname",
+		"getMimeInfo"
+	], "Correct methods are provided");
+
+	t.is(typeof interfacedMiddlewareUtil.getPathname, "function", "function getPathname is provided");
+	t.is(typeof interfacedMiddlewareUtil.getMimeInfo, "function", "function getMimeInfo is provided");
+});
+
+test("getInterface: specVersion undefined", async (t) => {
+	const middlewareUtil = new MiddlewareUtil();
+
+	const err = t.throws(() => {
+		middlewareUtil.getInterface();
+	});
+
+	t.is(err.message, "MiddlewareUtil: Unknown or unsupported specification version undefined",
+		"Throw with correct error message");
+});
+
+test("getInterface: specVersion unknown", async (t) => {
+	const middlewareUtil = new MiddlewareUtil();
+	const err = t.throws(() => {
+		middlewareUtil.getInterface("1.5");
+	});
+
+	t.is(err.message, "MiddlewareUtil: Unknown or unsupported specification version 1.5",
+		"Throw with correct error message");
+});