orator 3.0.11 → 4.0.1

package/package.json

@@ -1,69 +1,62 @@
 {
-  "name": "orator",
-  "version": "3.0.11",
-  "description": "Unopinionated restful web API server container",
-  "main": "source/Orator.js",
-  "scripts": {
-    "start": "node source/Orator.js",
-    "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"
-  },
-  "browser": {
-    "./source/Orator-Default-ServiceServers-Node.js": "./source/Orator-Default-ServiceServers-Web.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/stevenvelozo/orator.git"
-  },
-  "keywords": [
-    "rest",
-    "api",
-    "logging"
-  ],
-  "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/stevenvelozo/orator/issues"
-  },
-  "mocha": {
-    "diff": true,
-    "extension": [
-      "js"
+    "name": "orator",
+    "version": "4.0.1",
+    "description": "Unopinionated API behavior container - REST or IPC",
+    "main": "source/Orator.js",
+    "scripts": {
+        "start": "node source/Orator.js",
+        "coverage": "npx nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
+        "test": "npx mocha -u tdd -R spec",
+        "build": "npx quack build",
+        "docker-dev-build-image": "docker build ./ -f Dockerfile_LUXURYCode -t retold/orator:local",
+        "docker-dev-run": "docker run -it -d --name orator-dev -p 15277:8080 -p 34566:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/orator\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" orator-image:local",
+        "tests": "npx mocha -u tdd --exit -R spec --grep",
+        "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t orator-image:local",
+        "docker-dev-shell": "docker exec -it orator-dev /bin/bash"
+    },
+    "browser": {
+        "./source/Orator-Default-ServiceServer.js": "./source/Orator-Default-ServiceServer-Web.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/stevenvelozo/orator.git"
+    },
+    "keywords": [
+        "rest",
+        "api",
+        "logging"
     ],
-    "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": {
-    "browserify": "^17.0.0",
-    "chai": "4.3.7",
-    "fable": "^3.0.11",
-    "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",
-    "orator-serviceserver-restify": "^1.0.1"
-  },
-  "dependencies": {
-    "async": "^3.2.4",
-    "find-my-way": "^7.5.0"
-  }
+    "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
+    "license": "MIT",
+    "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": {
+        "fable": "^3.0.73",
+        "quackage": "^1.0.17"
+    },
+    "dependencies": {
+        "fable-serviceproviderbase": "^3.0.10",
+        "find-my-way": "^7.5.0",
+        "orator-serviceserver-base": "^1.0.0"
+    }
 }

package/source/Orator-Default-ServiceServer-Web.js

@@ -0,0 +1,4 @@
+/**
+* Default Service Server
+*/
+module.exports = require('./Orator-ServiceServer-IPC.js')

package/source/Orator-Default-ServiceServer.js

@@ -0,0 +1,4 @@
+/**
+* Default Service Server
+*/
+module.exports = require('./Orator-ServiceServer-IPC.js')

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

@@ -1,9 +1,26 @@
 class OratorServiceServerIPCSynthesizedResponse
 {
-	constructor(pLog, pRequestGUID)
+	constructor(pHandler, pLog, pRequestGUID)
 	{
 		this.log = pLog;
 
+		if (pHandler.hasOwnProperty('params'))
+		{
+			this.params = pHandler.params;
+		}
+		else
+		{
+			this.params = {};
+		}
+		if (pHandler.hasOwnProperty('searchParams'))
+		{
+			this.searchParams = pHandler.searchParams;
+		}
+		else
+		{
+			this.searchParams = {};
+		}
+
 		this.requestGUID = pRequestGUID;
 
 		this.responseData = null;

package/source/Orator-ServiceServer-IPC.js

@@ -1,29 +1,23 @@
-const libOratorServiceServerBase = require('./Orator-ServiceServer-Base.js');
+const libOratorServiceServerBase = require('orator-serviceserver-base');
 
 // 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');
-const libAsyncWaterfall = require("async/waterfall");
-const libAsyncEachOfSeries = require('async/eachOfSeries')
 
 class OratorServiceServerIPC extends libOratorServiceServerBase
 {
-	constructor(pOrator)
+	constructor(pFable, pOptions, pServiceHash)
 	{
-		super(pOrator);
+        super(pFable, pOptions, pServiceHash);
 
-		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.router = libFindMyWay(this.options);
 
 		this.ServiceServerType = 'IPC';
 
 		this.URL = 'IPC';
+		this.Port = 0;
 
 		this.preBehaviorFunctions = [];
 		this.behaviorMap = {};
@@ -32,16 +26,10 @@ class OratorServiceServerIPC extends libOratorServiceServerBase
 
 	use(fHandlerFunction)
 	{
-		if (!super.use(fHandlerFunction))
-		{
-			this.log.error(`IPC provider failed to map USE handler function!`);
-			return false;
-		}
-
-		this.preBehaviorFunctions.push(fHandlerFunction);
+		return this.addPreBehaviorFunction(fHandlerFunction);
 	}
 
-	addPostBehaviorFunction(fHandlerFunction)
+	addPreBehaviorFunction(fHandlerFunction)
 	{
 		if (!super.use(fHandlerFunction))
 		{
@@ -50,15 +38,24 @@ class OratorServiceServerIPC extends libOratorServiceServerBase
 		}
 
 		this.preBehaviorFunctions.push(fHandlerFunction);
+		return true;
 	}
 
 	executePreBehaviorFunctions(pRequest, pResponse, fNext)
 	{
-		libAsyncEachOfSeries(this.preBehaviorFunctions,
-			(fBehaviorFunction, pFunctionIndex, fCallback) =>
-			{
-				return fBehaviorFunction(pRequest, pResponse, fCallback);
-			},
+		let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+		for (let i = 0; i < this.preBehaviorFunctions.length; i++)
+		{
+			let tmpPreBehaviorFunction = this.preBehaviorFunctions[i];
+			tmpAnticipate.anticipate(
+				(fStageComplete) =>
+				{
+					return tmpPreBehaviorFunction(pRequest, pResponse, fStageComplete);
+				});
+		}
+
+		tmpAnticipate.wait(
 			(pError) =>
 			{
 				if (pError)
@@ -77,16 +74,25 @@ class OratorServiceServerIPC extends libOratorServiceServerBase
 			return false;
 		}
 
-		this.preBehaviorFunctions.push(fHandlerFunction);
+		this.postBehaviorFunctions.push(fHandlerFunction);
+		return true;
 	}
 
 	executePostBehaviorFunctions(pRequest, pResponse, fNext)
 	{
-		libAsyncEachOfSeries(this.postBehaviorFunctions,
-			(fBehaviorFunction, pFunctionIndex, fCallback) =>
-			{
-				return fBehaviorFunction(pRequest, pResponse, fCallback);
-			},
+		let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+		for (let i = 0; i < this.postBehaviorFunctions.length; i++)
+		{
+			let tmpPostBehaviorFunction = this.postBehaviorFunctions[i];
+			tmpAnticipate.anticipate(
+				(fStageComplete) =>
+				{
+					return tmpPostBehaviorFunction(pRequest, pResponse, fStageComplete);
+				});
+		}
+
+		tmpAnticipate.wait(
 			(pError) =>
 			{
 				if (pError)
@@ -117,52 +123,55 @@ class OratorServiceServerIPC extends libOratorServiceServerBase
 	{
 		// 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) =>
+		this.router.on(pMethod, pRoute, this.buildFindMyWayHandler(pRouteFunctionArray));
+		return true;
+	}
+
+	buildFindMyWayHandler(pRouteFunctionArray)
+	{
+		let tmpRouteFunctionArray = pRouteFunctionArray;
+		return (
+			(pRequest, pResponse, pData) =>
 			{
-				libAsyncWaterfall(
-					[
-						(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)=>
-						{
-							libAsyncEachOfSeries(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)=>
+				let tmpAnticipate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+				tmpAnticipate.anticipate(
+					(fNext)=>
 					{
-						if (pRequestError)
+						return this.executePreBehaviorFunctions(pRequest, pResponse, fNext);
+					});
+
+				for (let i = 0; i < tmpRouteFunctionArray.length; i++)
+				{
+					let tmpRouteFunction = tmpRouteFunctionArray[i];
+					tmpAnticipate.anticipate(
+						(fNext) =>
 						{
-							this.log.error(`IPC Provider behavior function ${pFunctionIndex} failed with error: ${pBehaviorFunctionError}`, pBehaviorFunctionError);
-						}
+							return tmpRouteFunction(pRequest, pResponse, fNext);
+						});
+				}
+
+				tmpAnticipate.anticipate(
+					(fStageComplete)=>
+					{
+						return this.executePostBehaviorFunctions(pRequest, pResponse, fStageComplete);
 					});
-			});
 
-		return true;
+				return new Promise(
+					(fResolve, fReject) =>
+					{
+						tmpAnticipate.wait(
+							(pBehaviorFunctionError) =>
+							{
+								if (pBehaviorFunctionError)
+								{
+									this.log.error(`IPC Provider behavior function ${pFunctionIndex} failed with error: ${pBehaviorFunctionError}`, pBehaviorFunctionError);
+									return fReject(pBehaviorFunctionError);
+								}
+								return fResolve();
+							});
+					});
+			});
 	}
 
 	// This is the virtualized "body parser"
@@ -218,33 +227,49 @@ class OratorServiceServerIPC extends libOratorServiceServerBase
 		// 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
-							()=>{};
+							false;
+
+		if (!tmpCallback)
+		{
+			throw new Error(`IPC Provider invoke() called without a callback function.`);
+		}
 
 		// Create a bare minimum request object for IPC to pass to our router
 		let tmpRequest = (
 			{
 				method: pMethod,
 				url: pRoute,
-				guid: this.orator.fable.getUUID()
+				guid: this.fable.getUUID()
 			});
 
+		// For now, dealing with no handler constraints.
+		let tmpHandler = this.router.find( tmpRequest.method, tmpRequest.url);
+
 		// Create a container for the IPC response data to be aggregated to from send() methodds
-		let tmpSynthesizedResponseData = new libOratorServiceServerIPCSynthesizedResponse(this.log, tmpRequest.guid);
+		let tmpSynthesizedResponseData = new libOratorServiceServerIPCSynthesizedResponse(tmpHandler, this.log, tmpRequest.guid);
+
+		// Map parsed params back to the request object
+		tmpRequest.params = tmpSynthesizedResponseData.params;
+		tmpRequest.searchParams = tmpSynthesizedResponseData.searchParams;
 
-		return this.router.lookup(
-			tmpRequest,
-			tmpSynthesizedResponseData,
-			(pError, pResults)=>
+		//params: handle._createParamsObject(params)//,
+        //searchParams: this.querystringParser(querystring)
+
+		tmpHandler.handler(tmpRequest, tmpSynthesizedResponseData, pData).then(
+			(pResults)=>
 			{
+				return tmpCallback(null, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData, pResults);
+			},
+			(pError)=>
+			{
+				this.log.trace('IPC Response Received', {Error: pError});
 				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);
-			});
+				return tmpCallback(pError, tmpSynthesizedResponseData.responseData, tmpSynthesizedResponseData);
+			}
+		);
 	}
 }