orator-static-server 1.0.0

package/.vscode/launch.json

@@ -0,0 +1,46 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Debug Harness",
+            "type": "pwa-node",
+            "request": "launch",
+            "outputCapture": "std",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/debug/Harness.js",
+            "presentation": {
+                "hidden": false,
+                "group": "",
+                "order": 1
+            }
+        },
+        {
+            "name": "Mocha Tests",
+            "args": [
+                "-u",
+                "tdd",
+                "--timeout",
+                "999999",
+                "--colors",
+                "${workspaceFolder}/test"
+            ],
+            "internalConsoleOptions": "openOnSessionStart",
+            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "pwa-node",
+            "presentation": {
+                "hidden": false,
+                "group": "",
+                "order": 2
+            }
+        }
+    ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Steven Velozo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# Orator Static File Server
+
+Very basic static file server for local development and lightweight tasks.
+
+Leverages restify static server.

package/debug/Harness.js

@@ -0,0 +1,72 @@
+const libFable = require('fable');
+
+const defaultFableSettings = (
+	{
+		Product:'Orator-Static',
+		ProductVersion: '1.0.0',
+		APIServerPort: 8766
+	});
+
+// Initialize Fable
+let _Fable = new libFable(defaultFableSettings);
+
+// Now initialize the Restify ServiceServer Fable Service
+_Fable.serviceManager.addServiceType('OratorServiceServer', require('orator-serviceserver-restify'));
+_Fable.serviceManager.instantiateServiceProvider('OratorServiceServer', 
+	{
+		RestifyConfiguration: { strictNext: true }
+	});
+
+// Now add the orator service to Fable
+_Fable.serviceManager.addServiceType('Orator', require('orator'));
+let _Orator = _Fable.serviceManager.instantiateServiceProvider('Orator', {});
+
+let tmpAnticipate = _Fable.newAnticipate();
+
+// Initialize the Orator server
+tmpAnticipate.anticipate(_Orator.initialize.bind(_Orator));
+
+// Add the static server service
+const libOratorServeStatic = require(`../source/Orator-Static-Server.js`);
+_Fable.serviceManager.addServiceType('OratorServeStatic', libOratorServeStatic);
+_Fable.serviceManager.instantiateServiceProvider('OratorServeStatic');
+
+// Create a simple custom endpoint on the server.
+tmpAnticipate.anticipate(
+	(fNext)=>
+	{
+		// Create an endpoint.  This can also be done after the service is started.
+		_Orator.serviceServer.get
+		(
+			'/test/:hash',
+			(pRequest, pResponse, fNext) =>
+			{
+				// Send back the request parameters
+				pResponse.send(pRequest.params);
+				_Orator.fable.log.info(`Endpoint sent parameters object:`, pRequest.params);
+				return fNext();
+			}
+		);
+		return fNext();
+	});
+
+// Map the ./serve/ folder to the root of the server.
+tmpAnticipate.anticipate(
+	(fNext)=>
+	{
+		_Fable.serviceManager.OratorServeStatic.addStaticRoute(_Orator, `${__dirname}/serve/`, 'index.html');
+		return fNext();
+	});
+
+// Now start the service server.
+tmpAnticipate.anticipate(_Orator.startService.bind(_Orator));
+
+tmpAnticipate.wait(
+	(pError)=>
+	{
+		if (pError)
+		{
+			_Fable.log.error('Error initializing Orator Service Server: '+pError.message, pError);
+		}
+		_Fable.log.info('Orator Service Server Initialized.');
+	});

package/debug/serve/index.html

@@ -0,0 +1,9 @@
+<html>
+<head>
+	<title>Debug</title>
+</head>
+<body>
+	<h1>Debug</h1>
+	<p>Debugging is the process of finding and resolving defects or problems within a computer program that prevent correct operation of computer software or a system.</p>
+</body>
+</html>

package/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "orator-static-server",
+    "version": "1.0.0",
+    "description": "Orator static file server.",
+    "main": "source/Orator-Static-Server.js",
+    "scripts": {
+        "test": "./node_modules/mocha/bin/_mocha --exit -u tdd -R spec",
+        "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
+        "start": "node debug/Harness.js",
+        "tests": "npx mocha -u tdd --exit -R spec --grep"
+    },
+    "mocha": {
+        "diff": true,
+        "extension": [
+            "js"
+        ],
+        "package": "./package.json",
+        "reporter": "spec",
+        "slow": "75",
+        "timeout": "5000",
+        "ui": "tdd",
+        "watch-files": [
+            "source/**/*.js",
+            "test/**/*.js"
+        ],
+        "watch-ignore": [
+            "lib/vendor"
+        ]
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/stevenvelozo/orator-static-server.git"
+    },
+    "author": "steven velozo <steven@velozo.com>",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/stevenvelozo/orator-static-server/issues"
+    },
+    "homepage": "https://github.com/stevenvelozo/orator-static-server#readme",
+    "dependencies": {
+        "finalhandler": "^1.3.1",
+        "orator-serviceserver-base": "^1.0.1",
+        "serve-static": "^1.16.2"
+    },
+    "devDependencies": {
+        "fable": "^3.0.145",
+        "orator": "^5.0.0",
+        "orator-serviceserver-restify": "^2.0.3",
+        "quackage": "^1.0.33"
+    }
+}

package/source/Orator-Static-Server.js

@@ -0,0 +1,98 @@
+const FableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libServeStatic = require('serve-static');
+const libFinalHandler = require('finalhandler');
+
+/**
+ * Fable service that provides a simple static file server.
+ */
+class OratorStaticFileService extends FableServiceProviderBase
+{
+	/**
+	 * 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;
+		}
+	}
+
+
+	/**
+	 * Brought over from old orator and ported to work in the same way.
+	 *
+	 * @param {object} pOrator 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.
+	 */
+	addStaticRoute(pOrator, pFilePath, pDefaultFile, pRoute, pRouteStrip, pParams)
+	{
+		if (typeof(pFilePath) !== 'string')
+		{
+				pOrator.fable.log.error('A file path must be passed in as part of the server.');
+				return false;
+		}
+
+		// Default to just serving from root
+		const tmpRoute = (typeof(pRoute) === 'undefined') ? '/*' : pRoute;
+		const tmpRouteStrip = (typeof(pRouteStrip) === 'undefined') ? '/' : pRouteStrip;
+
+		// Default to serving index.html
+		const tmpDefaultFile = (typeof(pDefaultFile) === 'undefined') ? 'index.html' : pDefaultFile;
+
+		pOrator.fable.log.info('Orator mapping static route to files: '+tmpRoute+' ==> '+pFilePath+' '+tmpDefaultFile);
+
+		// Add the route
+		pOrator.serviceServer.server.get(tmpRoute, (pRequest, pResponse, fNext) =>
+		{
+				// The split removes query string parameters so they are ignored by our static web server.
+				// The substring cuts that out from the file path so relative files serve from the folders and server
+				//FIXME: .....
+				// 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)
+				{
+					tmpPotentialSubfolderMagicHost = tmpHostSet[0];
+				}
+				if (tmpPotentialSubfolderMagicHost)
+				{
+					// Check if the subfolder exists
+					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}/`;
+					}
+				}
+				pRequest.url = pRequest.url.split('?')[0].substr(tmpRouteStrip.length) || '/';
+				pRequest.path = function()
+				{
+						return pRequest.url;
+				};
+				const tmpServe = libServeStatic(servePath, Object.assign({ index: tmpDefaultFile }, pParams));
+				tmpServe(pRequest, pResponse, libFinalHandler(pRequest, pResponse));
+		});
+		return true;
+	}
+}
+
+module.exports = OratorStaticFileService;

package/test/Orator-Static-Server-basic_tests.js

@@ -0,0 +1,62 @@
+/**
+* Unit tests for Orator
+* @license     MIT
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+const Chai = require("chai");
+const Expect = Chai.expect;
+const Assert = Chai.assert;
+
+const libFable = require('fable');
+const libOrator = require('orator');
+const libOratorStaticServer = require('../source/Orator-Static-Server.js');
+
+//const libSuperTest = require('supertest');
+
+suite
+(
+	'Orator Restify Abstraction',
+	() =>
+	{
+		suite
+		(
+			'Object Sanity',
+			() =>
+			{
+				test
+				(
+					'The class should initialize itself into a happy little object.',
+					function (fDone)
+					{
+						// Initialize fable
+						let tmpFable = new libFable();
+
+						// Add Restify as the default service server type
+						tmpFable.addServiceType('OratorStaticServer', libOratorStaticServer);
+
+						// We can safely create the service now if we want, or after Orator is created.  As long as it's before we initialize orator.
+						let tmpOratorServiceServerRestify = tmpFable.instantiateServiceProvider('OratorStaticServer', {});
+
+						// Add Orator as a service
+						tmpFable.addServiceType('Orator', libOrator);
+
+						// Initialize the Orator service
+						let tmpOrator = tmpFable.instantiateServiceProvider('Orator', {});
+						// Sanity check Orator
+						Expect(tmpOrator).to.be.an('object', 'Orator should initialize as an object directly from the require statement.');
+
+						tmpOrator.initialize(
+							(pError)=>
+							{
+								Expect(tmpOrator.startService).to.be.an('function');
+
+								Expect(tmpOrator.serviceServer.ServiceServerType).to.equal('IPC', 'The service server provider should be Restify.');
+								fDone();
+							});
+					}
+				);
+			}
+		);
+	}
+);