fable-serviceproviderbase 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Steven Velozo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# Fable Service Provider
+
+A very basic set of base classes to provide the interface for Fable services.
+This is used for instantiating connections to databases, extending core
+services and whatever other services.
+
+Some service types Fable provides out of the box:
+
+* settings
+* logging
+* uuid
+* templating
+
+
+## Basic Services
+
+There are two types of services -- just requiring the class provides a base 
+class for most services.  The constructor for this type takes in a fully
+initialized fable object.
+
+```
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+class SimpleService extends libFableServiceProviderBase
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'SimpleService';
+    }
+
+    doSomething()
+    {
+        this.fable.log.info(`SimpleService ${this.UUID}::${this.Hash} is doing something.`);
+    }
+}
+```
+
+## Core Pre-initialization Services
+
+For some service types, we want to instantiate behaviors before the fable
+class has been initialized.  These use a special service base that defers
+the connection of an initialized fable object until after it's created.
+
+The one caveat here is the fable service doesn't provide consistent settings,
+log or uuid functionality until they have been initialized and mapped in.
+
+If you want to use this base class, please refer to the fable service 
+manager code as well to get a good understanding of how initialization 
+differs from the basic services.
+
+
+```
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+class SimpleService extends libFableServiceProviderBase
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'SimpleService';
+    }
+
+    doSomething()
+    {
+        this.fable.log.info(`SimpleService ${this.UUID}::${this.Hash} is doing something.`);
+    }
+}
+```

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "fable-serviceproviderbase",
+  "version": "3.0.0",
+  "description": "Simple base classes for fable services.",
+  "main": "source/Fable-ServiceProviderBase.js",
+  "scripts": {
+    "start": "node source/Fable-ServiceProviderBase.js",
+    "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
+    "test": "./node_modules/.bin/mocha -u tdd -R spec"
+  },
+  "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"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stevenvelozo/fable-serviceproviderbase.git"
+  },
+  "keywords": [
+    "entity",
+    "behavior"
+  ],
+  "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/stevenvelozo/fable-serviceproviderbase/issues"
+  },
+  "homepage": "https://github.com/stevenvelozo/fable-serviceproviderbase",
+  "devDependencies": {
+    "chai": "4.3.7",
+    "fable": "^3.0.27",
+    "mocha": "10.2.0",
+    "nyc": "^15.1.0"
+  }
+}

package/source/Fable-ServiceProviderBase-Preinit.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 FableCoreServiceProviderBase
+{
+	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 = FableCoreServiceProviderBase;

package/source/Fable-ServiceProviderBase.js

@@ -0,0 +1,25 @@
+/**
+* Fable Service Base
+* @license MIT
+* @author <steven@velozo.com>
+*/
+
+class FableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		this.fable = pFable;
+
+		this.options = (typeof(pOptions) === 'object') ? pOptions : {};
+
+        this.serviceType = 'Unknown';
+
+        this.UUID = pFable.getUUID();
+
+        this.Hash = (typeof(pServiceHash) === 'string') ? pServiceHash : `${this.UUID}`;
+	}
+}
+
+module.exports = FableServiceProviderBase;
+
+module.exports.CoreServiceProviderBase = require('./Fable-ServiceProviderBase-Preinit.js');

package/test/FableServiceProvider_tests.js

@@ -0,0 +1,279 @@
+/**
+* Unit tests for Fable Servi
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+const libFable = require('fable');
+const libFableServiceProviderBase = require('../source/Fable-ServiceProviderBase.js');
+
+const Chai = require("chai");
+const Expect = Chai.expect;
+
+class SimpleService extends libFableServiceProviderBase
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'SimpleService';
+    }
+
+    doSomething()
+    {
+        this.fable.log.info(`SimpleService ${this.UUID}::${this.Hash} is doing something.`);
+    }
+}
+
+class MockDatabaseService extends libFableServiceProviderBase
+{
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'MockDatabaseService';
+    }
+
+    connect()
+    {
+        this.fable.log.info(`MockDatabaseService ${this.UUID}::${this.Hash} is connecting to a database.`);
+    }
+
+    commit(pRecord)
+    {
+        this.fable.log.info(`MockDatabaseService ${this.UUID}::${this.Hash} is committing a record ${pRecord}.`);
+    }
+}
+
+class MockCoreService extends libFableServiceProviderBase.CoreServiceProviderBase
+{
+    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',
+	function()
+	{
+		var testFable = false;
+
+		setup
+		(
+			function()
+			{
+			}
+		);
+
+		suite
+		(
+			'Service Manager',
+			function()
+			{
+				test
+				(
+					'Manually initialize a Service',
+					function()
+					{
+						testFable = new libFable();
+                        
+                        let tmpSimpleService = new SimpleService(testFable, {SomeOption: true});
+
+                        tmpSimpleService.doSomething();
+
+                        Expect(tmpSimpleService.Hash).to.be.a('string');
+					}
+				);
+				test
+				(
+					'Register a Service',
+					function()
+					{
+						testFable = new libFable();
+                        testFable.serviceManager.addServiceType('SimpleService');
+                        testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-123');
+
+                        Expect(testFable.serviceManager.services['SimpleService']['SimpleService-123']).to.be.an('object');
+					}
+				);
+				test
+				(
+					'Use the Default Service',
+					function()
+					{
+						testFable = new libFable();
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+                        testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-123');
+
+                        Expect(testFable.serviceManager.services['SimpleService']['SimpleService-123']).to.be.an('object');
+
+                        Expect(testFable.serviceManager.defaultServices['SimpleService']).to.be.an('object');
+
+                        testFable.serviceManager.defaultServices.SimpleService.doSomething();
+
+                        Expect(testFable.serviceManager.defaultServices['SimpleService'].Hash).to.equal('SimpleService-123');
+					}
+				);
+                test
+                (
+                    'Use the Default Service with a different hash',
+                    function()
+                    {
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+
+                        testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-13');
+
+                        testFable.serviceManager.services['SimpleService']['SimpleService-13'].doSomething();
+
+                        Expect(testFable.serviceManager.services['SimpleService']['SimpleService-13']).to.be.an('object');
+                    }
+                );
+
+                test
+                (
+                    'Instantiate a service without registering it to Fable',
+                    function()
+                    {
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+
+                        let tmpService = testFable.serviceManager.instantiateServiceProviderWithoutRegistration('SimpleService', {SomeOption: true}, 'SimpleService-99');
+
+                        Expect(testFable.services.SimpleService['SimpleService-99']).to.be.an('undefined');
+
+                        Expect(tmpService).to.be.an('object');
+                    }
+                );
+
+                test
+                (
+                    'Change the default service provider',
+                    function()
+                    {
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+                        testFable.serviceManager.addServiceType('DatabaseService', MockDatabaseService);
+
+                        testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true});
+                        testFable.serviceManager.defaultServices.SimpleService.doSomething();
+
+                        testFable.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'PrimaryConnection');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+                        testFable.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'SecondaryConnection');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+                        testFable.serviceManager.defaultServices.DatabaseService.connect();
+                        testFable.serviceManager.defaultServices.DatabaseService.commit('Test Record');
+
+                        testFable.serviceManager.setDefaultServiceInstantiation('DatabaseService', 'SecondaryConnection');
+
+                        testFable.serviceManager.defaultServices.DatabaseService.connect();
+                        testFable.serviceManager.defaultServices.DatabaseService.commit('Another Test Record');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('SecondaryConnection');
+                    }
+                );
+
+                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',
+                    function()
+                    {
+                        let testFable = new libFable({});
+
+                        testFable.serviceManager.addServiceType('SimpleService', SimpleService);
+                        testFable.serviceManager.addServiceType('DatabaseService', MockDatabaseService);
+
+                        testFable.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true});
+                        testFable.serviceManager.defaultServices.SimpleService.doSomething();
+
+                        testFable.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'PrimaryConnection');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+                        testFable.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'SecondaryConnection');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+                        testFable.serviceManager.defaultServices.DatabaseService.connect();
+                        testFable.serviceManager.defaultServices.DatabaseService.commit('Test Record');
+
+                        Expect(testFable.serviceManager.setDefaultServiceInstantiation('DatabaseService', 'TertiaryConnection')).to.be.false;
+
+                        testFable.serviceManager.defaultServices.DatabaseService.connect();
+                        testFable.serviceManager.defaultServices.DatabaseService.commit('Another Test Record');
+
+                        Expect(testFable.serviceManager.defaultServices.DatabaseService.Hash).to.equal('PrimaryConnection');
+                    }
+                );
+			}
+		);
+	}
+);