pict-serviceproviderbase 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 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,74 @@
+# Pict Service Provider
+
+A very basic set of base classes to provide the interface for Pict services.
+This is used for instantiating connections to databases, extending core
+services and whatever other services.
+
+Some service types Pict provides out of the box:
+
+* settings
+* logging
+* uuid
+* templating
+* providers
+* application state
+* views
+
+
+## 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 pict object.
+
+```
+const libPictServiceProviderBase = require('pict-serviceproviderbase');
+
+class SimpleService extends libPictServiceProviderBase
+{
+    constructor(pPict, pOptions, pServiceHash)
+    {
+        super(pPict, pOptions, pServiceHash);
+
+        this.serviceType = 'SimpleService';
+    }
+
+    doSomething()
+    {
+        this.pict.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 pict
+class has been initialized.  These use a special service base that defers
+the connection of an initialized pict object until after it's created.
+
+The one caveat here is the pict 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 pict service 
+manager code as well to get a good understanding of how initialization 
+differs from the basic services.
+
+
+```
+const libPictServiceProviderBase = require('pict-serviceproviderbase');
+
+class SimpleService extends libPictServiceProviderBase
+{
+    constructor(pPict, pOptions, pServiceHash)
+    {
+        super(pPict, pOptions, pServiceHash);
+
+        this.serviceType = 'SimpleService';
+    }
+
+    doSomething()
+    {
+        this.pict.log.info(`SimpleService ${this.UUID}::${this.Hash} is doing something.`);
+    }
+}
+```

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "pict-serviceproviderbase",
+    "version": "1.0.0",
+    "description": "Simple base classes for pict services.",
+    "main": "source/Pict-ServiceProviderBase.js",
+    "scripts": {
+        "start": "node source/Pict-ServiceProviderBase.js",
+        "test": "npx mocha -u tdd -R spec",
+        "tests": "npx mocha -u tdd --exit -R spec --grep",
+        "coverage": "npx nyc --reporter=lcov --reporter=text-lcov npx mocha -- -u tdd -R spec",
+        "build": "npx quack build"
+    },
+    "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/pict-serviceproviderbase.git"
+    },
+    "keywords": [],
+    "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/stevenvelozo/pict-serviceproviderbase/issues"
+    },
+    "homepage": "https://github.com/stevenvelozo/pict-serviceproviderbase",
+    "devDependencies": {
+        "quackage": "^1.0.45"
+    },
+    "dependencies": {
+        "fable-serviceproviderbase": "^3.0.15",
+        "pict": "^1.0.343"
+    }
+}

package/source/Pict-ServiceProviderBase.js

@@ -0,0 +1,31 @@
+const libPackage = require('../package.json');
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+class PictServiceProviderBase extends libFableServiceProviderBase
+{
+	// The constructor can be used in two ways:
+	// 1) With a fable, options object and service hash (the options object and service hash are optional)
+	// 2) With an object or nothing as the first parameter, where it will be treated as the options object
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		/** @type {Object} */
+		this._PackagePictServiceProvider = libPackage;
+	}
+
+	connectFable(pFable)
+	{
+		super.connectFable(pFable);
+
+		if (!this.pict)
+		{
+			this.pict = pFable;
+		}
+		return true;
+	}
+}
+
+module.exports = PictServiceProviderBase;
+// This is left here in case we want to go back to having different code/base class for "core" services
+module.exports.CoreServiceProviderBase = PictServiceProviderBase;

package/test/PictServiceProvider_tests.js

@@ -0,0 +1,302 @@
+/**
+* Unit tests for Pict Service Provider Base
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+const libPict = require('pict');
+const libPictServiceProviderBase = require('../source/Pict-ServiceProviderBase.js');
+
+const Chai = require("chai");
+const Expect = Chai.expect;
+
+class SimpleService extends libPictServiceProviderBase
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+
+		this.serviceType = 'SimpleService';
+	}
+
+	doSomething()
+	{
+		// Exercise something that is only in pict and not fable as well
+		this.pict.log.trace(`There are ${Object.keys(this.pict.providers).length} service providers registered in pict.`);
+		this.pict.log.info(`SimpleService ${this.UUID}::${this.Hash} is doing something.`);
+	}
+}
+
+class MockDatabaseService extends libPictServiceProviderBase
+{
+	constructor(pPict, pOptions, pServiceHash)
+	{
+		super(pPict, pOptions, pServiceHash);
+
+		this.serviceType = 'MockDatabaseService';
+	}
+
+	connect()
+	{
+		this.pict.log.info(`MockDatabaseService ${this.UUID}::${this.Hash} is connecting to a database.`);
+	}
+
+	commit(pRecord)
+	{
+		this.pict.log.info(`MockDatabaseService ${this.UUID}::${this.Hash} is committing a record ${pRecord}.`);
+	}
+}
+
+class MockCoreService extends libPictServiceProviderBase.CoreServiceProviderBase
+{
+	constructor(pOptions, pServiceHash)
+	{
+		super(pOptions, pServiceHash);
+
+		this.serviceType = 'MockCoreService';
+
+		
+	}
+
+	// Core services should be able to provide their behaviors before the Pict object is fully initialized.
+	magicBehavior(pData)
+	{
+		console.log(`MockCoreService ${this.UUID}::${this.Hash} is doing something magical with ${pData}.`);
+	}
+}
+
+suite
+(
+	'Pict Service Manager',
+	function()
+	{
+		var testPict = false;
+
+		setup
+		(
+			function()
+			{
+			}
+		);
+
+		suite
+		(
+			'Service Manager',
+			function()
+			{
+				test
+				(
+					'Manually initialize a Service',
+					function()
+					{
+						testPict = new libPict();
+
+						let tmpSimpleService = new SimpleService(testPict, {SomeOption: true});
+
+						tmpSimpleService.doSomething();
+
+						Expect(tmpSimpleService.Hash).to.be.a('string');
+
+						Expect(tmpSimpleService._PackagePictServiceProvider).to.be.an('object');
+						Expect(tmpSimpleService._PackagePictServiceProvider.name).to.equal('pict-serviceproviderbase');
+						Expect(tmpSimpleService._PackagePictServiceProvider.version)
+					}
+				);
+				test
+				(
+					'Register a Service',
+					function()
+					{
+						testPict = new libPict();
+						testPict.serviceManager.addServiceType('SimpleService');
+						testPict.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-123');
+
+						Expect(testPict.serviceManager.servicesMap['SimpleService']['SimpleService-123']).to.be.an('object');
+					}
+				);
+				test
+				(
+					'Use the Default Service',
+					function()
+					{
+						testPict = new libPict();
+						testPict.serviceManager.addServiceType('SimpleService', SimpleService);
+						let tmpSimpleService = testPict.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-123');
+
+						Expect(testPict.serviceManager.servicesMap['SimpleService']['SimpleService-123']).to.be.an('object');
+
+						// The passed-in magic stuff should work too.
+						tmpSimpleService.log.info(`There were almost ${tmpSimpleService.services.DataFormat.formatterDollars(9821229.37)} dollars just lying here!`);
+
+						Expect(testPict.serviceManager.servicesMap['SimpleService']).to.be.an('object');
+
+						testPict.serviceManager.services.SimpleService.doSomething();
+
+						Expect(testPict.serviceManager.services['SimpleService'].Hash).to.equal('SimpleService-123');
+					}
+				);
+				test
+				(
+					'Use the Default Service with a different hash',
+					function()
+					{
+						let testPict = new libPict({});
+
+						testPict.serviceManager.addServiceType('SimpleService', SimpleService);
+
+						testPict.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true}, 'SimpleService-13');
+
+						testPict.serviceManager.servicesMap['SimpleService']['SimpleService-13'].doSomething();
+
+						Expect(testPict.serviceManager.servicesMap['SimpleService']['SimpleService-13']).to.be.an('object');
+					}
+				);
+
+				test
+				(
+					'Instantiate a service without registering it to Pict',
+					function()
+					{
+						let testPict = new libPict({});
+
+						testPict.serviceManager.addServiceType('SimpleService', SimpleService);
+
+						let tmpService = testPict.serviceManager.instantiateServiceProviderWithoutRegistration('SimpleService', {SomeOption: true}, 'SimpleService-99');
+
+						Expect(testPict.servicesMap.SimpleService['SimpleService-99']).to.be.an('undefined');
+
+						Expect(tmpService).to.be.an('object');
+					}
+				);
+
+				test
+				(
+					'Change the default service provider',
+					function()
+					{
+						let testPict = new libPict({});
+
+						testPict.serviceManager.addServiceType('SimpleService', SimpleService);
+						testPict.serviceManager.addServiceType('DatabaseService', MockDatabaseService);
+
+						testPict.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true});
+						testPict.serviceManager.services.SimpleService.doSomething();
+
+						testPict.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'PrimaryConnection');
+
+						Expect(testPict.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+						testPict.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'SecondaryConnection');
+
+						Expect(testPict.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+						testPict.serviceManager.services.DatabaseService.connect();
+						testPict.serviceManager.services.DatabaseService.commit('Test Record');
+
+						testPict.serviceManager.setDefaultServiceInstantiation('DatabaseService', 'SecondaryConnection');
+
+						testPict.serviceManager.services.DatabaseService.connect();
+						testPict.serviceManager.services.DatabaseService.commit('Another Test Record');
+
+						Expect(testPict.serviceManager.services.DatabaseService.Hash).to.equal('SecondaryConnection');
+					}
+				);
+
+				test
+				(
+					'Construct a core service before Pict 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 Pict 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 Pict after Pict 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 testPict = new libPict({});
+
+						testPict.serviceManager.connectPreinitServiceProviderInstance(tmpCoreService);
+
+						Expect(testPict.servicesMap.MockCoreService['MockCoreService-2']).to.be.an('object');
+						Expect(testPict.services.MockCoreService).to.be.an('object');
+
+						Expect(testPict.services.MockCoreService.pict.log).to.be.an('object');
+					}
+				)
+
+				test
+				(
+					'Construct a service without a pict at all',
+					function()
+					{
+						let tmpService = new SimpleService({Setting:'Something'});
+
+						Expect(tmpService.options.Setting).to.equal('Something');
+						Expect(tmpService.UUID).to.be.a('string');
+					}
+				)
+
+				test
+				(
+					'Attempt to change the default service provider to a nonexistant provider',
+					function()
+					{
+						let testPict = new libPict({});
+
+						testPict.serviceManager.addServiceType('SimpleService', SimpleService);
+						testPict.serviceManager.addServiceType('DatabaseService', MockDatabaseService);
+
+						testPict.serviceManager.instantiateServiceProvider('SimpleService', {SomeOption: true});
+						testPict.serviceManager.services.SimpleService.doSomething();
+
+						testPict.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'PrimaryConnection');
+
+						Expect(testPict.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+						testPict.serviceManager.instantiateServiceProvider('DatabaseService', {ConnectionString: 'mongodb://localhost:27017/test'}, 'SecondaryConnection');
+
+						Expect(testPict.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+
+						testPict.serviceManager.services.DatabaseService.connect();
+						testPict.serviceManager.services.DatabaseService.commit('Test Record');
+
+						Expect(testPict.serviceManager.setDefaultServiceInstantiation('DatabaseService', 'TertiaryConnection')).to.be.false;
+
+						testPict.serviceManager.services.DatabaseService.connect();
+						testPict.serviceManager.services.DatabaseService.commit('Another Test Record');
+
+						Expect(testPict.serviceManager.services.DatabaseService.Hash).to.equal('PrimaryConnection');
+					}
+				);
+			}
+		);
+	}
+);