fable 3.0.86 → 3.0.87

package/debug/Harness.js

@@ -1,5 +1,4 @@
-let libBookstore = require('../retold-harness/bookstore-serve-meadow-endpoint-apis-run.js');
-/*
+//let libBookstore = require('../retold-harness/bookstore-serve-meadow-endpoint-apis-run.js');
 const libFable = require('../source/Fable.js');
 
 class SimpleService extends libFable.ServiceProviderBase
@@ -19,21 +18,21 @@ class SimpleService extends libFable.ServiceProviderBase
 
 let testFable = new libFable({"Product": "FableDebugHarness"});
 
-testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+testFable.addServiceType('SimpleService', SimpleService);
 
-testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-123');
+testFable.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-123');
 
 
-testFable.serviceManager.services['SimpleService']['SimpleService-123'].doSomething();
+testFable.servicesMap['SimpleService']['SimpleService-123'].doSomething();
 
-testFable.serviceManager.services['SimpleService']['SimpleService-123'].doSomething();
+testFable.SimpleService.doSomething();
 
-console.log(`Initialized Service ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].serviceType} as UUID ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].UUID} with hash ${testFable.serviceManager.services['SimpleService']['SimpleService-123'].Hash}`);
+console.log(`Initialized Service ${testFable.servicesMap['SimpleService']['SimpleService-123'].serviceType} as UUID ${testFable.servicesMap['SimpleService']['SimpleService-123'].UUID} with hash ${testFable.servicesMap['SimpleService']['SimpleService-123'].Hash}`);
 
-testFable.serviceManager.services['SimpleService']['SimpleService-123'].doSomething();
+testFable.servicesMap['SimpleService']['SimpleService-123'].doSomething();
 
 // Instantiate the RestClient Service Provider
-let tmpRestClient = testFable.serviceManager.instantiateServiceProvider('RestClient', {TraceLog: true}, 'RestClient-99');
+let tmpRestClient = testFable.instantiateServiceProvider('RestClient', {TraceLog: true}, 'RestClient-99');
 
 // Download the wiktionary entry for dog!
 tmpRestClient.getJSON('https://en.wiktionary.org/w/api.php?action=parse&prop=wikitext&format=json&page=dog',
@@ -41,4 +40,3 @@ tmpRestClient.getJSON('https://en.wiktionary.org/w/api.php?action=parse&prop=wik
     {
         testFable.log.info('Response received!');
     });
-*/

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.86",
+    "version": "3.0.87",
     "description": "An entity behavior management and API bundling library.",
     "main": "source/Fable.js",
     "scripts": {
@@ -61,7 +61,7 @@
         "data-arithmatic": "^1.0.7",
         "dayjs": "^1.11.10",
         "fable-log": "^3.0.12",
-        "fable-serviceproviderbase": "^3.0.10",
+        "fable-serviceproviderbase": "^3.0.12",
         "fable-settings": "^3.0.8",
         "fable-uuid": "^3.0.5",
         "manyfest": "^1.0.25",

package/retold-harness/bookstore-serve-api.js

@@ -3,9 +3,9 @@ const _Settings = require('./configuration-bookstore-serve-api.js');
 const libFable = require('fable');
 
 _Fable = new libFable(_Settings);
-_Fable.serviceManager.addServiceType('RetoldDataService', require('retold-data-service'));
+_Fable.addServiceType('RetoldDataService', require('retold-data-service'));
 // The RetoldDataService defaults to process.cwd() but we want to run this from wherever.
-_Fable.serviceManager.instantiateServiceProvider('RetoldDataService',
+_Fable.instantiateServiceProvider('RetoldDataService',
     {
         "FullMeadowSchemaPath": `${__dirname}/model/`,
 		"DALMeadowSchemaPath": `${__dirname}/model/meadow/`

package/source/Fable.js

@@ -7,57 +7,74 @@ const libFableSettings = require('fable-settings');
 const libFableUUID = require('fable-uuid');
 const libFableLog = require('fable-log');
 
-const libFableServiceManager = require('./Fable-ServiceManager.js');
+const libFableServiceBase = require('fable-serviceproviderbase');
 
-class Fable
+class Fable extends libFableServiceBase.CoreServiceProviderBase
 {
 	constructor(pSettings)
 	{
-		// Initialization Phase 0: Set up the lowest level state (core services)
-		// Container for the core services prototypes.
-		// This is here so if an API consumer changes the default for a core service,
-		// fable still runs with what was initialized.
-		this._coreServices = {};
+		super(pSettings);
+
+		// Initialization Phase 0: Set up the lowest level state (fable is a utility service manager at heart)
+		this.serviceType = 'ServiceManager';
+
+		// An array of the types of services available
+		this.serviceTypes = [];
+		// A map of instantiated services
+		this.servicesMap = {};
+		// A map of the default instantiated service by type
+		this.services = {};
+
+		// A map of class constructors for services
+		this.serviceClasses = {};
+
+		// If we need extra service initialization capabilities
+		this.extraServiceInitialization = false;
+
+
+		// Initialization Phase 1: Set up the core utility services
+		// These are things like power, water, and sewage.  They are required for fable to run (e.g. logging, settings, etc)
 
 		// Instantiate the default Settings Manager
-		this._coreServices.SettingsManager = new libFableSettings(pSettings);
+		this.SettingsManager = new libFableSettings(pSettings);
+		this.SettingsManager = this.SettingsManager;
 		// Instantiate the UUID generator
-		this._coreServices.UUID = new libFableUUID(this._coreServices.SettingsManager.settings);
+		this.UUID = new libFableUUID(this.SettingsManager.settings);
 		// Instantiate the logging system
-		this._coreServices.Logging = new libFableLog(this._coreServices.SettingsManager.settings);
-		this._coreServices.Logging.initialize();
+		this.Logging = new libFableLog(this.SettingsManager.settings);
+		this.Logging.initialize();
 
-		// Initialization Phase 1: Instantiate the service manager
-		// This is the start actual bootstrapping point for fable
-		this._coreServices.ServiceManager = new libFableServiceManager(this);
-		this.serviceManager = this._coreServices.ServiceManager;
-		this.serviceManager.connectFable(this);
-		// Bootstrapping of fable into the Service Manager is complete
+		// Initialization Phase 1.5: Instantiate the service manager
+		// This is the start actual bootstrapping point for fable.
+		// For consistency fable is treated as a service.
+		this.ServiceManager = this;
+		this.connectFable(this);
+		// --> Bootstrapping of fable into the Service Manager is complete
 
 		// Initialization Phase 2: Map in the default services.
 		// They will then be available in the Default service provider set as well.
-		this.serviceManager.connectPreinitServiceProviderInstance(this._coreServices.ServiceManager);
-		this.serviceManager.connectPreinitServiceProviderInstance(this._coreServices.UUID);
-		this.serviceManager.connectPreinitServiceProviderInstance(this._coreServices.Logging);
-		this.serviceManager.connectPreinitServiceProviderInstance(this._coreServices.SettingsManager);
+		this.connectPreinitServiceProviderInstance(this.UUID);
+		this.connectPreinitServiceProviderInstance(this.Logging);
+		this.connectPreinitServiceProviderInstance(this.SettingsManager);
 
 		// Initialize and instantiate the default baked-in Data Arithmatic service
-		this.serviceManager.addAndInstantiateServiceType('EnvironmentData', require('./services/Fable-Service-EnvironmentData.js'));
-		this.serviceManager.addServiceType('Template', require('./services/Fable-Service-Template.js'));
-		this.serviceManager.addServiceType('MetaTemplate', require('./services/Fable-Service-MetaTemplate.js'));
-		this.serviceManager.addServiceType('Anticipate', require('./services/Fable-Service-Anticipate.js'));
-		this.serviceManager.addAndInstantiateServiceType('Dates', require('./services/Fable-Service-DateManipulation.js'));
-		this.serviceManager.addAndInstantiateServiceType('DataFormat', require('./services/Fable-Service-DataFormat.js'));
-		this.serviceManager.addAndInstantiateServiceType('DataGeneration', require('./services/Fable-Service-DataGeneration.js'));
-		this.serviceManager.addAndInstantiateServiceType('Utility', require('./services/Fable-Service-Utility.js'));
-		this.serviceManager.addServiceType('Operation', require('./services/Fable-Service-Operation.js'));
-		this.serviceManager.addServiceType('RestClient', require('./services/Fable-Service-RestClient.js'));
-		this.serviceManager.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));
-		this.serviceManager.addServiceType('Manifest', require('manyfest'));
-		this.serviceManager.addServiceType('ObjectCache', require('cachetrax'));
-		this.serviceManager.addServiceType('FilePersistence', require('./services/Fable-Service-FilePersistence.js'));
+		this.addAndInstantiateServiceType('EnvironmentData', require('./services/Fable-Service-EnvironmentData.js'));
+		this.addServiceType('Template', require('./services/Fable-Service-Template.js'));
+		this.addServiceType('MetaTemplate', require('./services/Fable-Service-MetaTemplate.js'));
+		this.addServiceType('Anticipate', require('./services/Fable-Service-Anticipate.js'));
+		this.addAndInstantiateServiceType('Dates', require('./services/Fable-Service-DateManipulation.js'));
+		this.addAndInstantiateServiceType('DataFormat', require('./services/Fable-Service-DataFormat.js'));
+		this.addAndInstantiateServiceType('DataGeneration', require('./services/Fable-Service-DataGeneration.js'));
+		this.addAndInstantiateServiceType('Utility', require('./services/Fable-Service-Utility.js'));
+		this.addServiceType('Operation', require('./services/Fable-Service-Operation.js'));
+		this.addServiceType('RestClient', require('./services/Fable-Service-RestClient.js'));
+		this.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));
+		this.addServiceType('Manifest', require('manyfest'));
+		this.addServiceType('ObjectCache', require('cachetrax'));
+		this.addServiceType('FilePersistence', require('./services/Fable-Service-FilePersistence.js'));
 	}
 
+	/* State Accessors */
 	get isFable()
 	{
 		return true;
@@ -65,38 +82,158 @@ class Fable
 
 	get settings()
 	{
-		return this._coreServices.SettingsManager.settings;
+		return this.SettingsManager.settings;
 	}
 
 	get settingsManager()
 	{
-		return this._coreServices.SettingsManager;
+		return this.SettingsManager;
 	}
 
-	get log()
+	// For backwards compatibility
+	getUUID()
 	{
-		return this._coreServices.Logging;
+		return this.UUID.getUUID();
 	}
 
-	get services()
+	/* Service Manager Methods */
+	addServiceType(pServiceType, pServiceClass)
 	{
-		return this._coreServices.ServiceManager.services;
+		if (this.servicesMap.hasOwnProperty(pServiceType))
+		{
+			// TODO: Check if any services are running?
+			this.log.warn(`Adding a service type [${pServiceType}] that already exists.`);
+		}
+		else
+		{
+			// Add the container for instantiated services to go in
+			this.servicesMap[pServiceType] = {};
+
+			// Add the type to the list of types
+			this.serviceTypes.push(pServiceType);
+		}
+
+		// Using the static member of the class is a much more reliable way to check if it is a service class than instanceof
+		if ((typeof(pServiceClass) == 'function') && (pServiceClass.isFableService))
+		{
+			// Add the class to the list of classes
+			this.serviceClasses[pServiceType] = pServiceClass;
+		}
+		else
+		{
+			// Add the base class to the list of classes
+			this.log.error(`Attempted to add service type [${pServiceType}] with an invalid class.  Using base service class, which will not crash but won't provide meaningful services.`);
+			this.serviceClasses[pServiceType] = libFableServiceBase;
+		}
 	}
 
-	get servicesMap()
+	// This is for the services that are meant to run mostly single-instance so need a default at initialization
+	addAndInstantiateServiceType(pServiceType, pServiceClass)
 	{
-		return this._coreServices.ServiceManager.servicesMap;
+		this.addServiceType(pServiceType, pServiceClass);
+		return this.instantiateServiceProvider(pServiceType, {}, `${pServiceType}-Default`);
 	}
 
-	getUUID()
+	// Some services expect to be overloaded / customized class.
+	instantiateServiceProviderFromPrototype(pServiceType, pOptions, pCustomServiceHash, pServicePrototype)
+	{
+		// Instantiate the service
+		let tmpService = new pServicePrototype(this, pOptions, pCustomServiceHash);
+
+		if (this.extraServiceInitialization)
+		{
+			tmpService = this.extraServiceInitialization(tmpService);
+		}
+
+		// Add the service to the service map
+		this.servicesMap[pServiceType][tmpService.Hash] = tmpService;
+
+		// If this is the first service of this type, make it the default
+		if (!this.services.hasOwnProperty(pServiceType))
+		{
+			this.setDefaultServiceInstantiation(pServiceType, tmpService.Hash)
+		}
+
+		return tmpService;
+	}
+
+	instantiateServiceProvider(pServiceType, pOptions, pCustomServiceHash)
+	{
+		// Instantiate the service
+		let tmpService = this.instantiateServiceProviderWithoutRegistration(pServiceType, pOptions, pCustomServiceHash);
+
+		// Add the service to the service map
+		this.servicesMap[pServiceType][tmpService.Hash] = tmpService;
+
+		// If this is the first service of this type, make it the default
+		if (!this.services.hasOwnProperty(pServiceType))
+		{
+			this.setDefaultServiceInstantiation(pServiceType, tmpService.Hash)
+		}
+
+		return tmpService;
+	}
+
+	// Create a service provider but don't register it to live forever in fable.services
+	instantiateServiceProviderWithoutRegistration(pServiceType, pOptions, pCustomServiceHash)
+	{
+		// Instantiate the service
+		let tmpService = new this.serviceClasses[pServiceType](this, pOptions, pCustomServiceHash);
+		if (this.extraServiceInitialization)
+		{
+			tmpService = this.extraServiceInitialization(tmpService);
+		}
+		return tmpService;
+	}
+
+	// Connect an initialized service provider that came before Fable was initialized
+	connectPreinitServiceProviderInstance(pServiceInstance)
 	{
-		return this._coreServices.UUID.getUUID();
+		let tmpServiceType = pServiceInstance.serviceType;
+		let tmpServiceHash = pServiceInstance.Hash;
+
+		// The service should already be instantiated, so just connect it to fable
+		pServiceInstance.connectFable(this);
+
+		// Add the service type to the map if it isn't there yet
+		if (!this.servicesMap.hasOwnProperty(tmpServiceType))
+		{
+			// If the core service hasn't registered itself yet, create the service container for it.
+			// This means you couldn't register another with this type unless it was later registered with a constructor class.
+			this.servicesMap[tmpServiceType] = {};
+		}
+		// Add the service to the service map
+		this.servicesMap[tmpServiceType][tmpServiceHash] = pServiceInstance;
+
+		// If this is the first service of this type, make it the default
+		if (!this.services.hasOwnProperty(tmpServiceType))
+		{
+			this.setDefaultServiceInstantiation(tmpServiceType, tmpServiceHash, false);
+		}
+
+		return pServiceInstance;
 	}
 
-	get fable()
+	setDefaultServiceInstantiation(pServiceType, pServiceHash, pOverwriteService)
 	{
-		return this;
-	};
+		// Overwrite services by default, unless told not to
+		let tmpOverwriteService = (typeof(pOverwriteService) === 'undefined') ? true : pOverwriteService;
+		// Make sure the service exists
+		if (this.servicesMap[pServiceType].hasOwnProperty(pServiceHash))
+		{
+			if (!this.hasOwnProperty(pServiceType) || tmpOverwriteService)
+			{
+				this[pServiceType] = this.servicesMap[pServiceType][pServiceHash];
+			}
+			if (!this.services.hasOwnProperty(pServiceType) || tmpOverwriteService)
+			{
+				this.services[pServiceType] = this.servicesMap[pServiceType][pServiceHash];
+			}
+			return true;
+		}
+
+		return false;
+	}	
 }
 
 // This is for backwards compatibility
@@ -109,7 +246,7 @@ module.exports = Fable;
 module.exports.new = autoConstruct;
 
 module.exports.LogProviderBase = libFableLog.LogProviderBase;
-module.exports.ServiceProviderBase = libFableServiceManager.ServiceProviderBase;
-module.exports.CoreServiceProviderBase = libFableServiceManager.CoreServiceProviderBase;
+module.exports.ServiceProviderBase = libFableServiceBase;
+module.exports.CoreServiceProviderBase = libFableServiceBase.CoreServiceProviderBase;
 
 module.exports.precedent = libFableSettings.precedent;

package/source/services/Fable-Service-Anticipate.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 class FableServiceAnticipate extends libFableServiceBase
 {

package/source/services/Fable-Service-DataGeneration.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 class FableServiceDataGeneration extends libFableServiceBase
 {

package/source/services/Fable-Service-EnvironmentData-Web.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 class FableServiceEnvironmentData extends libFableServiceBase
 {

package/source/services/Fable-Service-EnvironmentData.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 class FableServiceEnvironmentData extends libFableServiceBase
 {

package/source/services/Fable-Service-FilePersistence-Web.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 //const libLokiDB = require('@lokidb/loki');
 
 class FableServiceFilePersistence extends libFableServiceBase
@@ -13,6 +13,7 @@ class FableServiceFilePersistence extends libFableServiceBase
 	existsSync(pPath)
 	{
 		//return libFS.existsSync(pPath);
+		console.log('I SHOULD BE IN YOUR BUILD YO');
 		return false;
 	}
 

package/source/services/Fable-Service-FilePersistence.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 const libFS = require('fs');
 const libPath = require('path');
@@ -40,12 +40,6 @@ class FableServiceFilePersistence extends libFableServiceBase
 		return fCallback(null, tmpFileExists);
 	}
 
-	writeFileSync(pFileName, pFileContent, pOptions)
-	{
-		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
-		return libFS.writeFileSync(pFileName, pFileContent, tmpOptions);
-	}
-
 	appendFileSync(pFileName, pAppendContent, pOptions)
 	{
 		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
@@ -62,6 +56,24 @@ class FableServiceFilePersistence extends libFableServiceBase
 		return libFS.rmdirSync(pFileName);
 	}
 
+	readFileSync(pFilePath, pOptions)
+	{
+		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
+		return libFS.readFileSync(pFilePath, tmpOptions);
+	}
+
+	readFile(pFilePath, pOptions, fCallback)
+	{
+		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
+		return libFS.readFile(pFilePath, tmpOptions, fCallback);
+	}
+
+	writeFileSync(pFileName, pFileContent, pOptions)
+	{
+		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
+		return libFS.writeFileSync(pFileName, pFileContent, tmpOptions);
+	}
+
 	writeFileSyncFromObject(pFileName, pObject)
 	{
 		return this.writeFileSync(pFileName, JSON.stringify(pObject, null, 4));
@@ -83,6 +95,12 @@ class FableServiceFilePersistence extends libFableServiceBase
 		}
 	}
 
+	writeFile(pFileName, pFileContent, pOptions, fCallback)
+	{
+		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
+		return libFS.writeFile(pFileName, pFileContent, tmpOptions, fCallback);
+	}
+
 	lineReaderFactory(pFilePath, fOnLine, fOnComplete, fOnError)
 	{
 		let tmpLineReader = {};

package/source/services/Fable-Service-MetaTemplate.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 /**
 * Precedent Meta-Templating

package/source/services/Fable-Service-Operation-DefaultSettings.js

@@ -4,7 +4,7 @@ module.exports = (
             "UUID": false,
             "Hash": false,
 
-            "Title": "",
+            "Name": "",
             "Summary": "",
 
             "Version": 0
@@ -15,12 +15,10 @@ module.exports = (
             "CompletionProgress": 0,
             "CompletionTimeElapsed": 0,
 
-            "Steps": 1,
-            "StepsCompleted": 0,
-
-            "StartTime": 0,
-            "EndTime": 0
+            "TimeStart": 0,
+            "TimeEnd": 0
         },
+        "Steps": [],
         "Errors": [],
         "Log": []
     }

package/source/services/Fable-Service-Operation.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 const _OperationStatePrototypeString = JSON.stringify(require('./Fable-Service-Operation-DefaultSettings.js'));
 
@@ -18,15 +18,108 @@ class FableOperation extends libFableServiceBase
 
 		this.state = JSON.parse(_OperationStatePrototypeString);
 
+		this.stepMap = {};
+		this.stepFunctions = {};
+
 		// Match the service instantiation to the operation.
 		this.state.Metadata.Hash = this.Hash;
 		this.state.Metadata.UUID = this.UUID;
 
-		this.name = (typeof(this.options.Name) == 'string') ? this.options.Name : `Unnamed Operation ${this.state.Metadata.UUID}`;
+		this.state.Metadata.Name = (typeof(this.options.Name) == 'string') ? this.options.Name : `Unnamed Operation ${this.state.Metadata.UUID}`;
+		this.name = this.state.Metadata.Name;
 
 		this.log = this;
 	}
 
+	execute(fExecutionCompleteCallback)
+	{
+		if (this.state.Status.TimeStart)
+		{
+			return fExecutionCompleteCallback(new Error(`Operation [${this.state.Metadata.UUID}] ${this.state.Metadata.Name} has already been executed!`));
+		}
+
+		this.state.Status.TimeStart = +new Date();
+
+		let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
+
+		for (let i = 0; i < this.state.Steps; i++)
+		{
+			tmpAnticipate.anticipate(this.stepFunctions[this.state.Steps[i].GUIDStep].bind(this));
+		}
+
+		// Wait for the anticipation to complete
+		tmpAnticipate.wait(
+			(pError) =>
+			{
+				this.state.Status.TimeEnd = +new Date();
+				return fExecutionCompleteCallback();
+			});
+	}
+
+/*
+	TODO: I've gone back and forth on whether this should be an object, JSON 
+	object prototype, or set of functions here.  Discuss with colleagues!
+*/
+	addStep(pGUIDStep, fStepFunction, pStepName, pStepDescription, pStepMetadata)
+	{
+		let tmpStep = {};
+		tmpStep.GUIDStep = (typeof(pGUIDStep) !== 'undefined') ? pGUIDStep : `STEP-${this.state.Steps.length}-${this.fable.DataGeneration.randomNumericString()}`;
+		tmpStep.Name = (typeof(pStepName) !== 'undefined') ? pStepName : `Step [${tmpStep.GUIDStep}]`;
+		tmpStep.Description = (typeof(pStepDescription) !== 'undefined') ? pStepDescription : `Step execution of ${tmpStep.Name}.`;
+		// TODO: Right now this allows an Array... do we want to block that?
+		tmpStep.Metadata = (typeof(pStepMetadata) === 'object') ? pStepMetadata : {};
+
+		tmpStep.TimeStart = false;
+		tmpStep.TimeEnd = false;
+
+		// There is an array of steps, in the Operation State itself ... push a step there
+		this.state.Steps.push(tmpStep);
+
+		this.stepMap[tmpStep.GUIDStep]
+		this.stepFunctions[tmpStep.GUIDStep] = fStepFunction;
+
+		this.state.Status.StepCount++;
+		return tmpStep;
+	}
+
+	getStep(pGUIDStep)
+	{
+		if (this.stepMap.hasOwnProperty(pGUIDStep))
+		{
+			return this.stepMap[pGUIDStep];
+		}
+
+		return false;
+	}
+
+	startStep(pGUIDStep)
+	{
+		let tmpStep = this.getStep(pGUIDStep);
+
+		if (tmpStep === false)
+		{
+			return false;
+		}
+
+		tmpStep.TimeStart = +new Date();
+
+		return tmpStep;
+	}
+
+	stopStep(pGUIDStep)
+	{
+		let tmpStep = this.getStep(pGUIDStep);
+
+		if (tmpStep === false)
+		{
+			return false;
+		}
+
+		tmpStep.TimeEnd = +new Date();
+
+		return tmpStep;
+	}
+
 	writeOperationLog(pLogLevel, pLogText, pLogObject)
 	{
 		this.state.Log.push(`${new Date().toUTCString()} [${pLogLevel}]: ${pLogText}`);
@@ -47,6 +140,7 @@ class FableOperation extends libFableServiceBase
 		}
 	}
 
+
 	trace(pLogText, pLogObject)
 	{
 		this.writeOperationLog('TRACE', pLogText, pLogObject);
@@ -85,6 +179,7 @@ class FableOperation extends libFableServiceBase
 		this.fable.log.fatal(pLogText, pLogObject);
 	}
 
+
 	/************************************************************************
 	 * BEGINNING OF -->  Telemetry Helpers
 	 */

package/source/services/Fable-Service-RestClient.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 const libSimpleGet = require('simple-get');
 const libCookie = require('cookie');

package/source/services/Fable-Service-Template.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 class FableServiceTemplate extends libFableServiceBase
 {

package/source/services/Fable-Service-Utility.js

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 // TODO: These are still pretty big -- consider the smaller polyfills
 const libAsyncWaterfall = require('async.waterfall');
@@ -56,7 +56,7 @@ class FableServiceUtility extends libFableServiceBase
 	// with the added twist of returning a precompiled function ready to go.
 	template(pTemplateText, pData)
 	{
-		let tmpTemplate = this.fable.serviceManager.instantiateServiceProviderWithoutRegistration('Template');
+		let tmpTemplate = this.fable.instantiateServiceProviderWithoutRegistration('Template');
 
 		return tmpTemplate.buildTemplateFunction(pTemplateText, pData);
 	}
@@ -64,7 +64,7 @@ class FableServiceUtility extends libFableServiceBase
 	// Build a template function from a template hash, and, register it with the service provider
 	buildHashedTemplate(pTemplateHash, pTemplateText, pData)
 	{
-		let tmpTemplate = this.fable.serviceManager.instantiateServiceProvider('Template', {}, pTemplateHash);
+		let tmpTemplate = this.fable.instantiateServiceProvider('Template', {}, pTemplateHash);
 
 		this.templates[pTemplateHash] = tmpTemplate.buildTemplateFunction(pTemplateText, pData);