orator 2.0.4 → 3.0.0

package/.config/code-server/config.yaml

@@ -0,0 +1,4 @@
+bind-addr: 127.0.0.1:8080
+auth: password
+password: luxury
+cert: false

package/.config/configstore/update-notifier-npm-check-updates.json

@@ -0,0 +1,4 @@
+{
+	"optOut": false,
+	"lastUpdateCheck": 1648097783781
+}

package/.config/configstore/update-notifier-npm.json

@@ -0,0 +1,4 @@
+{
+	"optOut": false,
+	"lastUpdateCheck": 1677357438471
+}

package/.vscode/launch.json

@@ -5,22 +5,42 @@
     "version": "0.2.0",
     "configurations": [
         {
+            "name": "Launch Debug Harness",
             "type": "node",
             "request": "launch",
+            "outputCapture": "std",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/debug/Harness.js",
+            "presentation": {
+                "hidden": false,
+                "group": "",
+                "order": 1
+            }
+        },
+        {
             "name": "Mocha Tests",
-            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
             "args": [
                 "-u",
                 "tdd",
-                "--bail",
                 "--timeout",
                 "999999",
                 "--colors",
-                "${workspaceFolder}/test/Orator_basic_tests.js",
-                "${workspaceFolder}/test/Orator_logging_tests.js",
-                "${workspaceFolder}/test/Orator-proxy_tests.js"
+                "${workspaceFolder}/test"
+            ],
+            "internalConsoleOptions": "openOnSessionStart",
+            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
             ],
-            "internalConsoleOptions": "openOnSessionStart"
+            "type": "pwa-node",
+            "presentation": {
+                "hidden": false,
+                "group": "",
+                "order": 2
+            }
         }
     ]
 }

package/Dockerfile_LUXURYCode

@@ -0,0 +1,69 @@
+# Use the codercom/code-server image
+FROM codercom/code-server:latest
+MAINTAINER steven velozo
+
+VOLUME /home/coder/.config
+VOLUME /home/coder/.vscode
+
+RUN echo "...installing debian dependencies..."
+RUN sudo apt update
+RUN sudo apt install vim curl tmux -y
+
+RUN echo "Building development image..."
+
+RUN echo "...installing vscode extensions..."
+
+# Mocha unit testing in the sidebar
+RUN code-server --install-extension hbenl.vscode-mocha-test-adapter
+RUN code-server --install-extension hbenl.test-adapter-converter
+RUN code-server --install-extension hbenl.vscode-test-explorer
+
+# Magic indentation rainbow
+RUN code-server --install-extension oderwat.indent-rainbow
+RUN code-server --install-extension dbaeumer.vscode-eslint
+
+# Contextual git
+RUN code-server --install-extension eamodio.gitlens
+
+# Other extensions (uncomment them to have them automagic, or run this from a terminal to install in the container):
+
+# Microsoft's AI code completion
+# RUN code-server --install-extension  VisualStudioExptTeam.vscodeintellicode
+
+# Live server -- make sure to open up the port on the docker image
+# RUN code-server --install-extension ritwickdey.LiveServer
+
+# Quick link to required modules' documentation
+# RUN code-server --install-extension bengreenier.vscode-node-readme
+
+# Switch up fonts
+# RUN code-server --install-extension evan-buss.font-switcher
+
+# Icons
+# RUN code-server --install-extension vscode-icons-team.vscode-icons
+# RUN code-server --install-extension PKief.material-icon-theme
+
+# Hover over CSS colors to see them previewed
+# RUN code-server --install-extension bierner.color-info
+
+# An easy on the eyes color theme
+# RUN code-server --install-extension daylerees.rainglow
+
+RUN echo "...mapping library specific volumes..."
+
+# Volume mapping for code
+VOLUME /home/coder/orator
+
+SHELL ["/bin/bash", "-c"]
+USER coder
+
+RUN echo "...installing node version manager..."
+# Because there is a .bashrc chicken/egg problem, we will create one here to simulate logging in.  This is not great.
+RUN touch ~/.bashrc && chmod +x ~/.bashrc
+RUN curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash
+
+RUN echo "...installing node version 14 as the default..."
+RUN . ~/.nvm/nvm.sh && source ~/.bashrc && nvm install 14
+RUN . ~/.nvm/nvm.sh && source ~/.bashrc && nvm alias default 14
+
+WORKDIR /home/coder/orator

package/debug/Harness.js

@@ -0,0 +1,42 @@
+// Load the orator module with a few simple routes
+const libOrator = require(__dirname+'/../source/Orator.js');
+// Uncomment the following line to test the restify server plug-in
+// > make sure to run "npm i orator-serviceserver-restify" from the parent directory first so the package is available
+// > please don't --save it!
+const libOratorServiceServerRestify = require('orator-serviceserver-restify');
+
+const tmpServiceServer = new libOrator(
+	{
+		"Product": "HarnessService",
+		"ProductVersion": "1.2.3",
+
+		"APIServerPort": 8080
+	}
+	// Uncomment the next line to enable restify! 
+	,libOratorServiceServerRestify
+);
+// Initialize the service server
+tmpServiceServer.initializeServiceServer();
+// Start the service
+tmpServiceServer.startService();
+
+// Add a GET endpoint
+tmpServiceServer.webServer.get
+(
+	'/test/:hash',
+	(pRequest, pResponse, fNext) =>
+	{
+		// Send back whatever was sent as "name" in the URI
+		pResponse.send(pRequest.params);
+		tmpServiceServer.log.info(`Service has served the test echo route!`);
+		return fNext();
+	}
+);
+
+// If this is a web server, invoke is likely not implemented and will error.
+let tmpURI = `/test/SomeHash`;
+tmpServiceServer.invoke('GET', tmpURI, null, 
+	(pError, pResponseData) =>
+	{
+		tmpServiceServer.log.info(`Response to [${tmpURI}] came back from IPC resulting in [${pResponseData}]!`)
+	});

package/package.json

@@ -1,17 +1,15 @@
 {
   "name": "orator",
-  "version": "2.0.4",
-  "description": "Restful web API server. Using restify 6.",
+  "version": "3.0.0",
+  "description": "Unopinionated restful web API server container",
   "main": "source/Orator.js",
   "scripts": {
     "start": "node source/Orator.js",
-    "coverage": "npm run coverage-normal && npm run coverage-cluster && npm run coverage-report",
-    "coverage-normal": "./node_modules/istanbul/lib/cli.js cover --dir ./coverage/normal ./node_modules/mocha/bin/_mocha -- --exit -u tdd -R spec",
-    "coverage-cluster": "./node_modules/istanbul/lib/cli.js cover --dir ./coverage/cluster ./node_modules/mocha/bin/_mocha -- --exit -u tdd -R spec ./test/Orator_cluster_test.js.deferred",
-    "coverage-report": "./node_modules/istanbul/lib/cli.js report",
-    "test": "npm run test-normal && npm run test-cluster",
-    "test-normal": "./node_modules/mocha/bin/_mocha --exit -u tdd -R spec",
-    "test-cluster": "./node_modules/mocha/bin/_mocha --exit -u tdd -R spec ./test/Orator_cluster_test.js.deferred"
+    "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
+    "test": "./node_modules/mocha/bin/_mocha --exit -u tdd -R spec",
+    "build": "./node_modules/.bin/gulp build",
+    "docker-dev-build-image": "docker build ./ -f Dockerfile_LUXURYCode -t retold/orator:local",
+    "docker-dev-run": "docker run -it -d --name retold-orator-dev -p 40000:8080 -p 48086:8086 -p 48088:8088 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/orator\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/orator:local"
   },
   "repository": {
     "type": "git",
@@ -27,28 +25,43 @@
   "bugs": {
     "url": "https://github.com/stevenvelozo/orator/issues"
   },
+  "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"
+    ]
+  },
   "homepage": "https://github.com/stevenvelozo/orator",
   "devDependencies": {
-    "async": "2.6.1",
-    "chai": "4.1.2",
-    "codeclimate-test-reporter": "0.5.0",
-    "coveralls": "3.0.2",
-    "istanbul": "0.4.5",
-    "mocha": "5.2.0",
-    "supertest": "3.1.0"
-  },
-  "optionalDependencies": {
-    "v8-profiler": "^5.7.0"
+    "browserify": "^17.0.0",
+    "chai": "4.3.7",
+    "gulp": "^4.0.2",
+    "gulp-babel": "^8.0.0",
+    "gulp-sourcemaps": "^3.0.0",
+    "gulp-terser": "^2.1.0",
+    "gulp-util": "^3.0.8",
+    "mocha": "10.2.0",
+    "nyc": "^15.1.0",
+    "vinyl-buffer": "^1.0.1",
+    "vinyl-source-stream": "^2.0.0"
   },
   "dependencies": {
+    "async": "^3.2.4",
     "cachetrax": "^1.0.0",
-    "cluster": "^0.7.7",
-    "fable": "~1.0.2",
-    "fable-uuid": "~1.0.2",
-    "http-forward": "^0.1.3",
-    "request": "^2.69.0",
-    "restify": "^6.4.0",
-    "restify-await-promise": "^1.0.0",
-    "restify-cors-middleware": "^1.1.1"
+    "fable": "~3.0.2",
+    "find-my-way": "^7.5.0",
+    "orator-serviceserver": "^1.0.1"
   }
 }

package/source/Orator-Default-Configuration.js

@@ -0,0 +1,10 @@
+// Simple default configuration for application, when none is provided
+
+module.exports = (
+{
+	"Product": "Unnamed_Service",
+	"ProductVersion": "0.0.1",
+
+	"ServicePort": 8080
+});
+

package/source/Orator-Default-ServiceServers-Node.js

@@ -0,0 +1,21 @@
+/**
+* Default Service Server Function
+*
+* @license MIT
+*
+* @author Steven Velozo <steven@velozo.com>
+*/
+
+// Return the servers that are available without extensions loaded
+getDefaultServiceServers = () =>
+{
+	let tmpDefaultServiceServers = {};
+
+	tmpDefaultServiceServers.ipc = require('./Orator-ServiceServer-IPC.js');
+
+	tmpDefaultServiceServers.default = tmpDefaultServiceServers.ipc;
+
+	return tmpDefaultServiceServers;
+}
+
+module.exports = getDefaultServiceServers();

package/source/Orator-ServiceServer-IPC-RouterConstrainer.js

@@ -0,0 +1,35 @@
+'use strict'
+
+// This is taken directly from the find-my-way documentation for custom constraints and only mildly edited
+const ipcResponseTypeStrategy = (
+	{
+		// strategy name for referencing in the route handler `constraints` options
+		name: 'ipc',
+		isAsync: true,
+
+		// storage factory for storing routes in the find-my-way route tree
+		storage:
+			()=>
+			{
+				let handlers = {};
+
+				return (
+					{
+						get: (type) => { return handlers[type] || null },
+						set: (type, store) => { handlers[type] = store }
+					});
+			},
+
+		// function to get the value of the constraint from each incoming request
+		deriveConstraint: (pRequest, pContext, fDone) =>
+			{
+				// If we wanted to deny the IPC request based on a constraint, we would do:
+				// fDone(new Error(`The request was denied because ____ in the Request object wasn't right...`));
+				return fDone(null, 'IPC');
+			},
+
+		// optional flag marking if handlers without constraints can match requests that have a value for this constraint
+		mustMatchWhenDerived: true
+	});
+
+module.exports = ipcResponseTypeStrategy;

package/source/Orator-ServiceServer-IPC-SynthesizedResponse.js

@@ -0,0 +1,56 @@
+class OratorServiceServerIPCSynthesizedResponse
+{
+	constructor(pLog, pRequestGUID)
+	{
+		this.log = pLog;
+
+		this.requestGUID = pRequestGUID;
+
+		this.responseData = null;
+		this.responseStatus = -1;
+	}
+
+	send(pData)
+	{
+		if (typeof(pData) == 'string')
+		{
+			// This is a string!  Append it to the responsedata.
+			if (this.responseData === null)
+			{
+				this.responseData = pData;
+				return true;
+			}
+			else if (typeof(this.responseData) == 'string')
+			{
+				this.responseData = this.responseData+pData;
+				return true;
+			}
+			else
+			{
+				this.log(`Request ${this.requestGUID} has tried to send() a string value after send()ing data type ${typeof(this.responseData)}.`, pData)
+				return false;
+			}
+		}
+		else if (typeof(pData) == 'object')
+		{
+			if (this.responseData === null)
+			{
+				this.responseData = JSON.stringify(pData);
+				return true;
+			}
+			else if (typeof(this.responseData) == 'string')
+			{
+				// TODO: Discuss best way to handle this / if to handle this
+				this.responseData += this.responseData+JSON.stringify(pData);
+				return true;
+			}
+			else
+			{
+				this.log(`Request ${this.requestGUID} has tried to send() an object value to be auto stringified after send()ing data type ${typeof(this.responseData)}.`, pData)
+				return false;
+			}
+		}
+	}
+}
+
+module.exports = OratorServiceServerIPCSynthesizedResponse;

package/source/Orator-ServiceServer-IPC.js

@@ -0,0 +1,214 @@
+const libOratorServiceServerBase = require('orator-serviceserver');
+
+// A synthesized response object, for simple IPC.
+const libOratorServiceServerIPCSynthesizedResponse = require('./Orator-ServiceServer-IPC-SynthesizedResponse.js');
+// A simple constrainer for the find-my-way router since we aren't using any kind of headers to pass version or host
+const libOratorServiceServerIPCCustomConstrainer = require('./Orator-ServiceServer-IPC-RouterConstrainer.js');
+
+// This library is the default router for our services
+const libFindMyWay = require('find-my-way');
+const libAsync = require('async');
+
+class OratorServiceServerIPC extends libOratorServiceServerBase
+{
+	constructor(pOrator)
+	{
+		super(pOrator);
+
+		this.routerOptions = (this.orator.settings.hasOwnProperty('router_options') && (typeof(this.orator.settings.router_options) == 'object')) ? this.orator.settings.router_options : {};
+		this.router = libFindMyWay(this.routerOptions);
+		this.router.addConstraintStrategy(libOratorServiceServerIPCCustomConstrainer);
+
+		this.URL = 'IPC';
+
+		this.preBehaviorFunctions = [];
+		this.behaviorMap = {};
+		this.postBehaviorFunctions = [];
+	}
+
+	executePreBehaviorFunctions(pRequest, pResponse, fNext)
+	{
+		libAsync.eachOfSeries(this.preBehaviorFunctions,
+			(fBehaviorFunction, pFunctionIndex, fCallback) =>
+			{
+				return fBehaviorFunction(pRequest, pResponse, fCallback);
+			},
+			(pError) =>
+			{
+				if (pError)
+				{
+					this.log.error(`IPC Provider preBehaviorFunction ${pFunctionIndex} failed with error: ${pError}`, pError);
+				}
+				return fNext(pError);
+			});
+	}
+
+	executePostBehaviorFunctions(pRequest, pResponse, fNext)
+	{
+		libAsync.eachOfSeries(this.postBehaviorFunctions,
+			(fBehaviorFunction, pFunctionIndex, fCallback) =>
+			{
+				return fBehaviorFunction(pRequest, pResponse, fCallback);
+			},
+			(pError) =>
+			{
+				if (pError)
+				{
+					this.log.error(`IPC Provider postBehaviorFunction ${pFunctionIndex} failed with error: ${pError}`, pError);
+				}
+				return fNext(pError);
+			});
+	}
+
+	/*
+	 * Service Route Creation Functions
+	 *
+	 * These base functions provide basic validation for the routes, but don't actually 
+	 * do anything with them.  The design intent here is to allow derived classes to call
+	 * these functions to validate that they conform to expected standards.
+	 *
+	 * Something like:
+
+		get (pRoute, ...fRouteProcessingFunctions)
+		{
+			//...now we can do our actual get mapping function!....
+		}
+
+	 * This pattern and calling super is totally optional, obviously.
+	 *************************************************************************/
+	addRouteProcessor(pMethod, pRoute, pRouteFunctionArray)
+	{
+		// We have a constrainer on IPC so we can control channels eventually, if we like.
+		// For now it just makes sure it was added with an IPC service server.
+		this.router.on(pMethod, pRoute, { constraints: { "ipc": "IPC" } },
+			(pRequest, pResponse, pParameters) =>
+			{
+				libAsync.waterfall(
+					[
+						(fStageComplete)=>
+						{
+							// Added to make this mimic what we saw with route parsing in the old restify
+							pRequest.params = pParameters;
+							return fStageComplete();
+						},
+						(fStageComplete)=>
+						{
+							return this.executePreBehaviorFunctions(pRequest, pResponse, fStageComplete);
+						},
+						(fStageComplete)=>
+						{
+							libAsync.eachOfSeries(pRouteFunctionArray,
+								(fBehaviorFunction, pFunctionIndex, fCallback) =>
+								{
+									return fBehaviorFunction(pRequest, pResponse, fCallback);
+								},
+								(pBehaviorFunctionError) =>
+								{
+									if (pBehaviorFunctionError)
+									{
+										this.log.error(`IPC Provider behavior function ${pFunctionIndex} failed with error: ${pBehaviorFunctionError}`, pBehaviorFunctionError);
+										return fNext(pError);
+									}
+								});
+						},
+						(fStageComplete)=>
+						{
+							return this.executePostBehaviorFunctions(pRequest, pResponse, fStageComplete);
+						}
+					],
+					(pRequestError)=>
+					{
+						if (pRequestError)
+						{
+							this.log.error(`IPC Provider behavior function ${pFunctionIndex} failed with error: ${pBehaviorFunctionError}`, pBehaviorFunctionError);
+						}
+					});
+			});
+
+		return true;
+	}
+
+	get(pRoute, ...fRouteProcessingFunctions)
+	{
+		if (!super.get(pRoute, ...fRouteProcessingFunctions))
+		{
+			this.log.error(`IPC provider failed to map GET route [${pRoute}]!`);
+			return false;
+		}
+
+		return this.addRouteProcessor('GET', pRoute, Array.from(fRouteProcessingFunctions));
+	}
+
+	put(pRoute, ...fRouteProcessingFunctions)
+	{
+		if (!super.get(pRoute, ...fRouteProcessingFunctions))
+		{
+			this.log.error(`IPC provider failed to map PUT route [${pRoute}]!`);
+			return false;
+		}
+
+		return true;
+	}
+
+	post(pRoute, ...fRouteProcessingFunctions)
+	{
+		if (!super.get(pRoute, ...fRouteProcessingFunctions))
+		{
+			this.log.error(`IPC provider failed to map POST route [${pRoute}]!`);
+			return false;
+		}
+
+		return true;
+	}
+
+	del(pRoute, ...fRouteProcessingFunctions)
+	{
+		if (!super.get(pRoute, ...fRouteProcessingFunctions))
+		{
+			this.log.error(`IPC provider failed to map DEL route [${pRoute}]!`);
+			return false;
+		}
+
+		return true;
+	}
+	/*************************************************************************
+	 * End of Service Route Creation Functions
+	 */
+
+	// Programmatically invoke a route
+	invoke(pMethod, pRoute, pData, fCallback)
+	{
+		// If the data is skipped and a callback is parameter 3, do the right thing
+		let tmpCallback = (typeof(fCallback) == 'function') ? fCallback : 
+							(typeof(pData) == 'function') ? pData :
+							// This is here in case the developer passed no callback and just wants to fire and forget the IPC call which might not be async safe
+							()=>{};
+
+		// Create a bare minimum request object for IPC to pass to our router
+		let tmpRequest = (
+			{
+				method: pMethod,
+				url: pRoute,
+				guid: this.orator.fable.getUUID()
+			});
+
+		// Create a container for the IPC response data to be aggregated to from send() methodds
+		let tmpSynthesizedResponseData = new libOratorServiceServerIPCSynthesizedResponse(this.log, tmpRequest.guid);
+
+		return this.router.lookup(
+			tmpRequest,
+			tmpSynthesizedResponseData,
+			(pError, pResults)=>
+			{
+				if (pError)
+				{
+					this.log.error(`IPC Request Error Request GUID [${tmpRequest.guid}] handling route [${pRoute}]: ${pError}`, {Error: pError, Route: pRoute, Data: pData});
+				}
+
+				// by default, send data back through 
+				return tmpCallback(pError, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData, pResults);
+			});
+	}
+}
+
+module.exports = OratorServiceServerIPC;