fable 3.0.26 → 3.0.27

package/gulpfile-config.json

@@ -5,7 +5,7 @@
 
 	"LibraryOutputFolder": "./dist/",
 
-	"LibraryUniminifiedFileName": "fable.compatible.js",
+	"LibraryUniminifiedFileName": "fable.js",
 
-	"LibraryMinifiedFileName": "fable.compatible.min.js"
+	"LibraryMinifiedFileName": "fable.min.js"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.0.26",
+  "version": "3.0.27",
   "description": "An entity behavior management and API bundling library.",
   "main": "source/Fable.js",
   "scripts": {
@@ -67,6 +67,7 @@
     "fable-log": "^3.0.7",
     "fable-settings": "^3.0.3",
     "fable-uuid": "^3.0.2",
-    "precedent": "^1.0.10"
+    "precedent": "^1.0.10",
+    "simple-get": "^4.0.1"
   }
 }

package/source/Fable-PreinitServiceProviderBase.js

@@ -0,0 +1,36 @@
+/**
+* Fable Core Pre-initialization Service Base
+*
+* For a couple services, we need to be able to instantiate them before the Fable object is fully initialized.
+* This is a base class for those services.
+*
+* @license MIT
+* @author <steven@velozo.com>
+*/
+
+class FablePreinitServiceProviderBase
+{
+	constructor(pOptions, pServiceHash)
+	{
+		this.fable = false;
+
+		this.options = (typeof(pOptions) === 'object') ? pOptions : {};
+
+        this.serviceType = 'Unknown';
+
+		// The hash will be a non-standard UUID ... the UUID service uses this base class!
+        this.UUID = `CORESVC-${Math.floor((Math.random() * (99999 - 10000)) + 10000)}`;
+
+        this.Hash = (typeof(pServiceHash) === 'string') ? pServiceHash : `${this.UUID}`;
+	}
+
+	// After fable is initialized, it would be expected to be wired in as a normal service.
+	connectFable(pFable)
+	{
+		this.fable = pFable;
+
+		return true;
+	}
+}
+
+module.exports = FablePreinitServiceProviderBase;

package/source/Fable-ServiceManager.js

@@ -69,6 +69,33 @@ class FableService
 		return tmpService;
 	}
 
+	// Connect an initialized service provider that came before Fable was initialized
+	connectPreinitServiceProviderInstance(pServiceInstance)
+	{
+		let tmpServiceType = pServiceInstance.serviceType;
+		let tmpServiceHash = pServiceInstance.Hash;
+
+		// The service should already be instantiated, so just connect it to fable
+		pServiceInstance.connectFable(this.fable);
+
+		if (!this.services.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.services[tmpServiceType] = {};
+		}
+		// Add the service to the service map
+		this.services[tmpServiceType][tmpServiceHash] = pServiceInstance;
+
+		// If this is the first service of this type, make it the default
+		if (!this.defaultServices.hasOwnProperty(tmpServiceType))
+		{
+			this.defaultServices[tmpServiceType] = pServiceInstance;
+		}
+
+		return pServiceInstance;
+	}
+
 	setDefaultServiceInstantiation(pServiceType, pServiceHash)
 	{
 		if (this.services[pServiceType].hasOwnProperty(pServiceHash))

package/source/Fable.js

@@ -3,16 +3,20 @@
 * @license MIT
 * @author <steven@velozo.com>
 */
+// Pre-init services
 const libFableSettings = require('fable-settings');
 const libFableUUID = require('fable-uuid');
 const libFableLog = require('fable-log');
 
+const libFablePreinitServiceProviderBase = require('./Fable-PreinitServiceProviderBase.js');
 const libFableServiceManager = require('./Fable-ServiceManager.js');
 
-const libFableServiceDataArithmatic = require('./Fable-Service-DataArithmatic.js');
-const libFableServiceTemplate = require('./Fable-Service-Template.js');
-const libFableServiceMetaTemplate = require('./Fable-Service-MetaTemplate.js');
-const libFableServiceUtility = require('./Fable-Service-Utility.js');
+// Services
+const libFableServiceDataArithmatic = require('./services/Fable-Service-DataArithmatic.js');
+const libFableServiceMetaTemplate = require('./services/Fable-Service-MetaTemplate.js');
+const libFableServiceRestClient = require('./services/Fable-Service-RestClient.js');
+const libFableServiceTemplate = require('./services/Fable-Service-Template.js');
+const libFableServiceUtility = require('./services/Fable-Service-Utility.js');
 
 const libFableOperation = require('./Fable-Operation.js');
 
@@ -58,6 +62,9 @@ class Fable
 		this.fable.serviceManager.instantiateServiceProvider('Utility', {}, 'Default-Service-Utility');
 		this.Utility = this.serviceManager.defaultServices.Utility;
 
+		// Add the REST Client service type
+		this.serviceManager.addServiceType('RestClient', libFableServiceRestClient);
+
 		this.services = this.serviceManager.services;
 		this.defaultServices = this.serviceManager.defaultServices;
 	}
@@ -118,5 +125,6 @@ module.exports.new = autoConstruct;
 
 module.exports.LogProviderBase = libFableLog.LogProviderBase;
 module.exports.ServiceProviderBase = libFableServiceManager.ServiceProviderBase;
+module.exports.PreinitServiceProviderBase = libFablePreinitServiceProviderBase;
 
 module.exports.precedent = libFableSettings.precedent;

package/source/{Fable-Service-DataArithmatic.js → services/Fable-Service-DataArithmatic.js}

@@ -1,4 +1,5 @@
-const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+const libFableServiceBase = require('../Fable-ServiceProviderBase.js');
+
 const libDataArithmatic = require('data-arithmatic');
 
 class FableServiceDataArithmatic extends libFableServiceBase

package/source/{Fable-Service-MetaTemplate.js → services/Fable-Service-MetaTemplate.js}

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+const libFableServiceBase = require('../Fable-ServiceProviderBase.js');
 
 const libPrecedent = require('precedent');
 

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

@@ -0,0 +1,17 @@
+const libFableServiceBase = require('../Fable-ServiceProviderBase.js');
+
+const libSimpleGet = require('simple-get');
+
+class FableServiceRestClient extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'RestClient';
+
+        this._SimpleGet = new libSimpleGet();
+	}
+}
+
+module.exports = FableServiceRestClient;

package/source/{Fable-Service-Template.js → services/Fable-Service-Template.js}

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

package/source/{Fable-Service-Utility.js → services/Fable-Service-Utility.js}

@@ -1,4 +1,4 @@
-const libFableServiceBase = require('./Fable-ServiceProviderBase.js');
+const libFableServiceBase = require('../Fable-ServiceProviderBase.js');
 
 
 // TODO: These are still pretty big -- consider the smaller polyfills

package/test/FableServiceManager_tests.js

@@ -46,6 +46,22 @@ class MockDatabaseService extends libFable.ServiceProviderBase
     }
 }
 
+class MockCoreService extends libFable.PreinitServiceProviderBase
+{
+    constructor(pOptions, pServiceHash)
+    {
+        super(pOptions, pServiceHash);
+
+        this.serviceType = 'MockCoreService';
+    }
+
+    // Core services should be able to provide their behaviors before the Fable object is fully initialized.
+    magicBehavior(pData)
+    {
+        console.log(`MockCoreService ${this.UUID}::${this.Hash} is doing something magical with ${pData}.`);
+    }
+}
+
 suite
 (
 	'Fable Service Manager',
@@ -162,6 +178,54 @@ suite
                     }
                 );
 
+                test
+                (
+                    'Construct a core service before Fable is initialized',
+                    function()
+                    {
+                        let tmpCoreService = new MockCoreService({SomeOption: true});
+
+                        Expect(tmpCoreService).to.be.an('object');
+
+                        tmpCoreService.magicBehavior('MAGICTESTDATA');
+                    }
+                )
+                test
+                (
+                    'Construct a core service with a hash before Fable is initialized',
+                    function()
+                    {
+                        let tmpCoreService = new MockCoreService({SomeOption: true}, 'MockCoreService-1');
+
+                        Expect(tmpCoreService).to.be.an('object');
+                        Expect(tmpCoreService.Hash).to.equal('MockCoreService-1');
+
+                        tmpCoreService.magicBehavior('MAGICTESTDATA');
+                    }
+                )
+
+                test
+                (
+                    'Construct a core service and attach it to Fable after Fable is initialized',
+                    function()
+                    {
+
+                        let tmpCoreService = new MockCoreService({SomeOption: true}, 'MockCoreService-2');
+
+                        Expect(tmpCoreService).to.be.an('object');
+                        Expect(tmpCoreService.Hash).to.equal('MockCoreService-2');
+
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.connectPreinitServiceProviderInstance(tmpCoreService);
+
+                        Expect(testFable.services.MockCoreService['MockCoreService-2']).to.be.an('object');
+                        Expect(testFable.defaultServices.MockCoreService).to.be.an('object');
+
+                        Expect(testFable.defaultServices.MockCoreService.fable.log).to.be.an('object');
+                    }
+                )
+
                 test
                 (
                     'Attempt to change the default service provider to a nonexistant provider',