orator-static-server 1.0.1 → 1.0.2

package/source/Orator-Static-Server.js

@@ -1,89 +1,97 @@
-const FableServiceProviderBase = require('fable-serviceproviderbase');
+/**
+* Orator Static Server
+*
+* Static file serving for Orator API servers.  Handles MIME type detection,
+* route stripping, default files, magic subdomain folder mapping, and
+* Content-Type headers so browsers render HTML instead of downloading it.
+*
+* @license MIT
+*
+* @author Steven Velozo <steven@velozo.com>
+*/
+
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
 
 const libServeStatic = require('serve-static');
 const libFinalHandler = require('finalhandler');
+const libMime = require('mime');
 
 /**
- * Fable service that provides a simple static file server.
+ * @class OratorStaticServer
+ * @extends libFableServiceProviderBase
+ *
+ * A service provider that manages static file serving routes on an Orator instance.
  */
-class OratorStaticFileService extends FableServiceProviderBase
+class OratorStaticServer extends libFableServiceProviderBase
 {
-	/**
-	 * Construct a service instance.
-	 *
-	 * @param {object} pFable The fable instance for the application. Used for logging and settings.
-	 * @param {object} pOptions Custom settings for this service instance.
-	 * @param {string} pServiceHash The hash for this service instance.
-	 *
-	 * @return a static file service instance.
-	 */
 	constructor(pFable, pOptions, pServiceHash)
 	{
 		super(pFable, pOptions, pServiceHash);
 
-		if (typeof(this.options.proxyUrl) != 'string' || !this.options.proxyUrl.startsWith('http'))
-		{
-			this.log.trace('API proxy url falling back to settings...', { badUrl: this.options.proxyUrl });
-			this.options.proxyUrl = this.fable.settings.APIProxyUrl;
-		}
-
-		// By jacking up the log level, the static server will become more and more communicative.
-		this.logLevel = (`LogLevel` in this.options) ? this.options.LogLevel
-						: `OratorStaticServerLogLevel` in this.fable.settings ? this.fable.settings.OratorStaticServerLogLevel
-						: 0;
+		this.serviceType = 'OratorStaticServer';
 
-		// The magic hosts option will look for the leftmost subdomain and use it as a subfolder.
-		this.magicHostsEnabled = (`MagicHosts` in this.options) ? this.options.LogLevel
-						: `OratorStaticServerMagicHosts` in this.fable.settings ? this.fable.settings.OratorStaticServerLogLevel
-						: false;
+		// Keep track of registered static routes for introspection
+		this.routes = [];
 
-		// The default folder to serve from
-		this.defaultFolder = (`DefaultFolder` in this.options) ? this.options.DefaultFolder
-						: (`OratorStaticServerDefaultFolder` in this.fable.settings) ? this.fable.settings.OratorStaticServerDefaultFolder
-						: false;
+		// This is here because libMime has a breaking change from v1 to v2 and the lookup function was update to be getType per https://stackoverflow.com/a/60741078
+		// We don't want to introspect properties on this library every single time we need to check mime types.
+		// Therefore we are setting this boolean here and using it to branch.
+		this.oldLibMime = false;
+		if ('lookup' in libMime)
+		{
+			this.oldLibMime = true;
+		}
+	}
 
-		// Whether or not to auto map the route
-		this.autoMap = (`AutoMap` in this.options) ? this.options.AutoMap
-						: (`OratorStaticServerAutoMap` in this.fable.settings) ? this.fable.settings.OratorStaticServerAutoMap
-						: false;
+	/**
+	 * Set the Content-Type header on a response based on the file name.
+	 *
+	 * @param {string} pFileName - The file name (or path) to detect MIME type from.
+	 * @param {Object} pResponse - The HTTP response object.
+	 */
+	setMimeHeader(pFileName, pResponse)
+	{
+		let tmpHeader;
 
-		this.fable.instantiateServiceProviderIfNotExists('FilePersistence');
+		if (this.oldLibMime)
+		{
+			tmpHeader = libMime.lookup(pFileName);
+		}
+		else
+		{
+			tmpHeader = libMime.getType(pFileName);
+		}
 
-		if (this.autoMap && this.defaultFolder)
+		if (!tmpHeader)
 		{
-			this.log.info(`Auto-mapping static route [/*] to files in ==> [${this.defaultFolder}] default file [index.html]`);
-			this.addStaticRoute(this.defaultFolder);
+			tmpHeader = 'application/octet-stream';
 		}
-	}
 
+		pResponse.setHeader('Content-Type', tmpHeader);
+	}
 
 	/**
-	 * Brought over from old orator and ported to work in the same way.
+	 * Add a static file serving route to the Orator instance.
 	 *
-	 * @param {object} this.fable.Orator The Orator instance.
-	 * @param {string} pFilePath The path on disk that we are serving files from.
-	 * @param {string?} pDefaultFile (optional) The default file served if no specific file is requested.
-	 * @param {string?} pRoute (optional) The route matcher that will be used. Defaults to everything.
-	 * @param {string?} pRouteStrip (optional) If provided, this prefix will be removed from URL paths before being served.
-	 * @param {object?} pParams (optional) Additional parameters to pass to serve-static.
-	 * @return {boolean} true if the handler was successfully installed, otherwise false.
+	 * @param {string} pFilePath - The path on disk to serve files from.
+	 * @param {string} [pDefaultFile='index.html'] - The default file for directory requests.
+	 * @param {string} [pRoute='/*'] - The route pattern to match.
+	 * @param {string} [pRouteStrip='/'] - URL prefix to strip before filesystem lookup.
+	 * @param {object} [pParams={}] - Additional parameters passed to serve-static.
+	 * @returns {boolean} true if the route was successfully installed.
 	 */
 	addStaticRoute(pFilePath, pDefaultFile, pRoute, pRouteStrip, pParams)
 	{
-		if (!'Orator' in this.fable)
-		{
-			this.fable.log.error('Orator must be initialized before adding a static route.');
-			return false;
-		}
-		if (!'serviceServer' in this.fable.Orator)
+		if (!this.fable.Orator)
 		{
-			this.fable.log.error('Orator must have a service server initialized before adding a static route.');
+			this.log.error('OratorStaticServer requires an Orator instance to be registered with Fable.');
 			return false;
 		}
+
 		if (typeof(pFilePath) !== 'string')
 		{
-				this.fable.log.error('A file path must be passed in as part of the server.');
-				return false;
+			this.fable.log.error('A file path must be passed in as part of the server.');
+			return false;
 		}
 
 		// Default to just serving from root
@@ -93,19 +101,45 @@ class OratorStaticFileService extends FableServiceProviderBase
 		// Default to serving index.html
 		const tmpDefaultFile = (typeof(pDefaultFile) === 'undefined') ? 'index.html' : pDefaultFile;
 
+		let tmpOrator = this.fable.Orator;
+
 		this.fable.log.info('Orator mapping static route to files: '+tmpRoute+' ==> '+pFilePath+' '+tmpDefaultFile);
 
-		// Add the route
-		this.fable.Orator.serviceServer.get(tmpRoute, (pRequest, pResponse, fNext) =>
+		// Ensure FilePersistence is available for the magic subdomain subfolder check
+		if (!this.fable.FilePersistence)
 		{
-				let servePath = pFilePath;
+			this.fable.serviceManager.instantiateServiceProvider('FilePersistence');
+		}
 
-				if (this.magicHostsEnabled)
-				{
+		// Try the service server's built-in serveStatic first (e.g. restify's serveStaticFiles plugin).
+		// This handles MIME types, caching headers, and streaming correctly without our manual intervention.
+		if (typeof(tmpOrator.serviceServer.serveStatic) === 'function')
+		{
+			let tmpServeStaticOptions = Object.assign({ directory: pFilePath, default: tmpDefaultFile }, pParams);
+			if (tmpOrator.serviceServer.serveStatic(tmpRoute, tmpServeStaticOptions))
+			{
+				this.routes.push(
+					{
+						filePath: pFilePath,
+						defaultFile: tmpDefaultFile,
+						route: tmpRoute,
+						routeStrip: tmpRouteStrip,
+						params: pParams || {}
+					});
+				return true;
+			}
+		}
+
+		// Fall back to the serve-static library approach (used by the IPC service server and other
+		// service servers that don't have a built-in serveStatic implementation).
+		tmpOrator.serviceServer.get(tmpRoute,
+			(pRequest, pResponse, fNext) =>
+			{
 					// See if there is a magic subdomain put at the beginning of a request.
 					// If there is, then we need to see if there is a subfolder and add that to the file path
 					let tmpHostSet = pRequest.headers.host.split('.');
 					let tmpPotentialSubfolderMagicHost = false;
+					let servePath = pFilePath;
 					// Check if there are more than one host in the host header (this will be 127 a lot)
 					if (tmpHostSet.length > 1)
 					{
@@ -113,44 +147,45 @@ class OratorStaticFileService extends FableServiceProviderBase
 					}
 					if (tmpPotentialSubfolderMagicHost)
 					{
-						// Check if the subfolder exists
+						// Check if the subfolder exists -- this is only one dimensional for now
 						let tmpPotentialSubfolder = servePath + tmpPotentialSubfolderMagicHost;
 						if (this.fable.FilePersistence.libFS.existsSync(tmpPotentialSubfolder))
 						{
 							// If it does, then we need to add it to the file path
 							servePath = `${tmpPotentialSubfolder}/`;
-							if (this.logLevel > 1)
-							{
-								this.fable.log.trace(`Orator static magic mapped subdomain ${tmpPotentialSubfolderMagicHost}, altering servepath to [${servePath}]`);
-							}
 						}
 					}
-				}
-
-				pRequest.url = pRequest.url.split('?')[0].substr(tmpRouteStrip.length) || '/';
-				pRequest.path = function()
-				{
-						return pRequest.url;
-				};
+					pRequest.url = pRequest.url.split('?')[0].substr(tmpRouteStrip.length) || '/';
+					pRequest.path = function()
+					{
+							return pRequest.url;
+					};
 
-				if (this.logLevel > 0)
-				{
-					this.fable.log.trace(`Static request from host [${pRequest.headers.host}] URL [${pRequest.url}]`,
-						{
-							Host: pRequest.headers.host,
-							UserAgent: pRequest.headers['user-agent'],
-							Method: pRequest.method,
-							ClientInterface: {Family: pRequest.connection.remoteFamily, Address: pRequest.connection.remoteAddress, Port: pRequest.connection.remotePort},
-							ServerInterface: {Family: pRequest.connection.localFamily, Address: pRequest.connection.localAddress, Port: pRequest.connection.localPort},
-							URL: pRequest.url
-						}
-					);
-				}
-				const tmpServe = libServeStatic(servePath, Object.assign({ index: tmpDefaultFile }, pParams));
-				tmpServe(pRequest, pResponse, libFinalHandler(pRequest, pResponse));
-		});
+					// When the URL is a directory (e.g. '/' or '/docs/'), use the default file for MIME detection
+					// so the browser gets text/html instead of application/octet-stream
+					let tmpMimeTarget = pRequest.url;
+					if (tmpMimeTarget.endsWith('/') || tmpMimeTarget.indexOf('.') < 0)
+					{
+						tmpMimeTarget = tmpDefaultFile;
+					}
+					this.setMimeHeader(tmpMimeTarget, pResponse);
+
+					const tmpServe = libServeStatic(servePath, Object.assign({ index: tmpDefaultFile }, pParams));
+					tmpServe(pRequest, pResponse, libFinalHandler(pRequest, pResponse));
+					// TODO: This may break things if a post request send handler is setup...
+					//fNext();
+			});
+
+		this.routes.push(
+			{
+				filePath: pFilePath,
+				defaultFile: tmpDefaultFile,
+				route: tmpRoute,
+				routeStrip: tmpRouteStrip,
+				params: pParams || {}
+			});
 		return true;
 	}
 }
 
-module.exports = OratorStaticFileService;
+module.exports = OratorStaticServer;