fable 3.0.85 → 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.85",
+    "version": "3.0.87",
     "description": "An entity behavior management and API bundling library.",
     "main": "source/Fable.js",
     "scripts": {
@@ -10,7 +10,8 @@
         "build": "npx quack build",
         "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t fable-image:local",
         "docker-dev-run": "docker run -it -d --name fable-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" fable-image:local",
-        "docker-dev-shell": "docker exec -it fable-dev /bin/bash"
+        "docker-dev-shell": "docker exec -it fable-dev /bin/bash",
+        "tests": "./node_modules/mocha/bin/_mocha -u tdd --exit -R spec --grep"
     },
     "mocha": {
         "diff": true,
@@ -60,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,37 +1,33 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 //const libLokiDB = require('@lokidb/loki');
 
 class FableServiceFilePersistence extends libFableServiceBase
 {
 	constructor(pFable, pOptions, pServiceHash)
 	{
-        super(pFable, pOptions, pServiceHash);
+		super(pFable, pOptions, pServiceHash);
 
-        this.serviceType = 'FilePersistence';
-
-        if (!this.options.hasOwnProperty('Mode'))
-        {
-            this.options.Mode = parseInt('0777', 8) & ~process.umask();
-        }
+		this.serviceType = 'FilePersistence';
 	}
 
-    existsSync(pPath)
-    {
-        //return libFS.existsSync(pPath);
-        return false;
-    }
+	existsSync(pPath)
+	{
+		//return libFS.existsSync(pPath);
+		console.log('I SHOULD BE IN YOUR BUILD YO');
+		return false;
+	}
 
-    exists(pPath, fCallback)
-    {
-        let tmpFileExists = this.existsSync(pPath);;
+	exists(pPath, fCallback)
+	{
+		let tmpFileExists = this.existsSync(pPath);;
 
-        return fCallback(null, tmpFileExists);
-    }
+		return fCallback(null, tmpFileExists);
+	}
 
-    makeFolderRecursive (pParameters, fCallback)
-    {
-        return fCallback();
-    }
+	makeFolderRecursive(pParameters, fCallback)
+	{
+		return fCallback();
+	}
 }
 
 module.exports = FableServiceFilePersistence;

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

@@ -1,7 +1,8 @@
-const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+const libFableServiceBase = require('fable-serviceproviderbase');
 
 const libFS = require('fs');
 const libPath = require('path');
+const libReadline = require('readline');
 
 
 class FableServiceFilePersistence extends libFableServiceBase
@@ -17,8 +18,9 @@ class FableServiceFilePersistence extends libFableServiceBase
 			this.options.Mode = parseInt('0777', 8) & ~process.umask();
 		}
 
-		this.currentInputFolder = `/tmp`;
-		this.currentOutputFolder = `/tmp`;
+		this.libFS = libFS;
+		this.libPath = libPath;
+		this.libReadline = libReadline;
 	}
 
 	joinPath(...pPathArray)
@@ -38,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;
@@ -60,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));
@@ -81,26 +95,40 @@ class FableServiceFilePersistence extends libFableServiceBase
 		}
 	}
 
-	// Default folder behaviors
-
-	getDefaultOutputPath(pFileName)
+	writeFile(pFileName, pFileContent, pOptions, fCallback)
 	{
-		return libPath.join(this.currentOutputFolder, pFileName);
+		let tmpOptions = (typeof(pOptions) === 'undefined') ? 'utf8' : pOptions;
+		return libFS.writeFile(pFileName, pFileContent, tmpOptions, fCallback);
 	}
 
-	dataFolderWriteSync(pFileName, pFileContent)
+	lineReaderFactory(pFilePath, fOnLine, fOnComplete, fOnError)
 	{
-		return this.writeFileSync(this.getDefaultOutputPath(pFileName), pFileContent);
-	}
+		let tmpLineReader = {};
 
-	dataFolderWriteSyncFromObject(pFileName, pObject)
-	{
-		return this.writeFileSyncFromObject(this.getDefaultOutputPath(pFileName), pObject);
-	}
+		if (typeof(pFilePath) != 'string')
+		{
+			return false;
+		}
 
-	dataFolderWriteSyncFromArray(pFileName, pFileArray)
-	{
-		return this.writeFileSyncFromArray(this.getDefaultOutputPath(pFileName), pFileArray);
+		tmpLineReader.filePath = pFilePath;
+
+		tmpLineReader.fileStream = libFS.createReadStream(tmpLineReader.filePath);
+
+		tmpLineReader.reader = libReadline.createInterface({ input: tmpLineReader.fileStream, crlfDelay: Infinity });
+
+		if (typeof(fOnError) === 'function')
+		{
+			tmpLineReader.reader.on('error', fOnError);
+		}
+
+		tmpLineReader.reader.on('line', (typeof(fOnLine) === 'function') ? fOnLine : () => {});
+
+		if (typeof(fOnComplete) === 'function')
+		{
+			tmpLineReader.reader.on('close', fOnComplete);
+		}
+
+		return tmpLineReader;
 	}
 
 	// Folder management

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": []
     }