orator 4.0.0 → 4.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "orator",
-    "version": "4.0.0",
+    "version": "4.0.2",
     "description": "Unopinionated API behavior container - REST or IPC",
     "main": "source/Orator.js",
     "scripts": {
@@ -51,11 +51,12 @@
     },
     "homepage": "https://github.com/stevenvelozo/orator",
     "devDependencies": {
-        "fable": "^3.0.73",
-        "quackage": "^1.0.17"
+        "fable": "^3.0.96",
+        "quackage": "^1.0.24"
     },
     "dependencies": {
-        "fable-serviceproviderbase": "^3.0.10",
-        "find-my-way": "^7.5.0"
+        "fable-serviceproviderbase": "^3.0.12",
+        "find-my-way": "^7.7.0",
+        "orator-serviceserver-base": "^1.0.0"
     }
 }

package/source/Orator-ServiceServer-IPC.js

@@ -1,9 +1,7 @@
-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');
@@ -15,7 +13,6 @@ class OratorServiceServerIPC extends libOratorServiceServerBase
         super(pFable, pOptions, pServiceHash);
 
 		this.router = libFindMyWay(this.options);
-		//this.router.addConstraintStrategy(libOratorServiceServerIPCCustomConstrainer);
 
 		this.ServiceServerType = 'IPC';
 

package/source/Orator.js

@@ -118,7 +118,7 @@ class Orator extends libFableServiceProviderBase
 
 	initialize(fCallback)
 	{
-		// I hate this -- is there a reason to not require a callback?
+		// I hate this -- as long as we want to be "mostly" backwards compatible it needs to do it though
 		let tmpCallback = (typeof(fCallback) === 'function') ? fCallback : () => {};
 
 		if (!this.initializeTimestamp)
@@ -165,7 +165,7 @@ class Orator extends libFableServiceProviderBase
 			this.options.ServicePort,
 			(pError)	=>
 			{
-				this.log.info(`${this.serviceServer.Name} listening at ${this.serviceServer.URL} port ${this.serviceServer.Port}`);
+				this.log.info(`${this.serviceServer.Name} listening on port ${this.options.ServicePort}`);
 				return fNext(pError);
 			}
 		);
@@ -257,7 +257,7 @@ class Orator extends libFableServiceProviderBase
 		// this accessor function is called.
 		if (!this.serviceServer)
 		{
-			this.initializeServiceServer();
+			this.initialize();
 		}
 
 		return this.serviceServer;
@@ -268,5 +268,5 @@ class Orator extends libFableServiceProviderBase
 }
 
 module.exports = Orator;
-module.exports.ServiceServerBase = require('./Orator-ServiceServer-Base.js');
+module.exports.ServiceServerBase = require('orator-serviceserver-base');
 module.exports.ServiceServerIPC = require('./Orator-ServiceServer-IPC.js');

package/source/Orator-ServiceServer-Base.js

@@ -1,227 +0,0 @@
-const libFableServiceProviderBase = require('fable-serviceproviderbase');
-
-class OratorServiceServerBase extends libFableServiceProviderBase
-{
-	constructor(pFable, pOptions, pServiceHash)
-	{
-        super(pFable, pOptions, pServiceHash);
-
-        this.serviceType = 'OratorServiceServer';
-
-		this.ServiceServerType = 'Base';
-
-		this.Name = this.fable.settings.Product;
-		this.URL = 'BASE_SERVICE_SERVER';
-		this.Port = this.options.ServicePort;
-
-		this.Active = false;
-	}
-
-	/*
-	 * Service Lifecycle Functions
-	 *************************************************************************/
-	listen(pPort, fCallback)
-	{
-		// Sometimes, listen does not listen on network calls.
-		this.Active = true;
-
-		return fCallback();
-	}
-
-	close(fCallback)
-	{
-		this.Active = false;
-
-		return fCallback();
-	}
-	/*************************************************************************
-	 * End of Service Lifecycle Functions
-	 */
-
-	/*
-	 * Content parsing functions
-	 *************************************************************************/
-	bodyParser(pOptions)
-	{
-		return (pRequest, pResponse, fNext) => 
-			{
-				fNext();
-			};
-	}
-	/*************************************************************************
-	 * End of Service Lifecycle Functions
-	 */
-
-	/*
-	 * 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)
-		{
-			if (!super.get(pRoute, ...fRouteProcessingFunctions))
-			{
-				this.log.error(`Restify provider failed to map route [${pRoute}]!`);
-				return false;
-			}
-
-			//...now we can do our actual get mapping function!....
-		}
-
-	 * This pattern and calling super is totally optional, obviously.
-	 *************************************************************************/
-	use(fHandlerFunction)
-	{
-		if (typeof(fHandlerFunction) != 'function')
-		{
-			this.log.error(`Orator USE global handler mapping failed -- parameter was expected to be a function with prototype function(Request, Response, Next) but type was ${typeof(fHandlerFunction)} instead of a string.`)
-			return false;
-		}
-
-		return true;
-	}
-
-	doGet(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	get(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator GET Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doGet(pRoute, ...fRouteProcessingFunctions);
-	}
-	getWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.get(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doPut(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	put(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator PUT Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doPut(pRoute, ...fRouteProcessingFunctions);
-	}
-	putWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.put(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doPost(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	post(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator POST Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doPost(pRoute, ...fRouteProcessingFunctions);
-	}
-	postWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.post(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doDel(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	del(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator DEL Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doDel(pRoute, ...fRouteProcessingFunctions);
-	}
-	delWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.del(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doPatch(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	patch(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator PATCH Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doPatch(pRoute, ...fRouteProcessingFunctions);
-	}
-	patchWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.patch(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doOpts(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	opts(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator OPTS Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-		return this.doOpts(pRoute, ...fRouteProcessingFunctions);
-	}
-	optsWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.opts(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-
-	doHead(pRoute, ...fRouteProcessingFunctions)
-	{
-		return true;
-	}
-	head(pRoute, ...fRouteProcessingFunctions)
-	{
-		if (typeof(pRoute) != 'string')
-		{
-			this.log.error(`Orator HEAD Route mapping failed -- route parameter was ${typeof(pRoute)} instead of a string.`)
-			return false;
-		}
-
-		return true;
-	}
-	headWithBodyParser(pRoute, ...fRouteProcessingFunctions)
-	{
-		return this.head(pRoute, this.bodyParser(), ...fRouteProcessingFunctions);
-	}
-	/*************************************************************************
-	 * End of Service Route Creation Functions
-	 */
-
-	// Programmatically invoke a route
-	invoke(pMethod, pRoute, pData, fCallback)
-	{
-		// The base class version of this does nothing
-		this.log.debug(`Orator invoke called for route [${pRoute}] and landed on the base class; the service provider likely does not implement programmatic invoke capabilities.`, pData);
-		return false;
-	}
-}
-
-module.exports = OratorServiceServerBase;

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

@@ -1,35 +0,0 @@
-'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;