retold-data-service 1.0.4 → 2.0.1

package/.config/configstore/update-notifier-npm.json

@@ -1,10 +1,4 @@
 {
 	"optOut": false,
-	"lastUpdateCheck": 1686012350867,
-	"update": {
-		"latest": "9.6.7",
-		"current": "6.14.18",
-		"type": "major",
-		"name": "npm"
-	}
+	"lastUpdateCheck": 1684950851047
 }

package/README.md

@@ -1,37 +1,27 @@
 # Retold Data Service
 
-Provide a consistent back or mid-tier data service with boilerplate tooling
-abstracted behind configuration.  Leaving a simple mechanism to add complexity
-where desired.
+Provide a consistent back or mid-tier data service.
 
 ## Basic Usage
 
-This library is meant to be run in any of three types of configurations:
+This library can run in any of three types of configurations:
 
 * Configuration Driven
 * Managed via Backplane Endpoints
 * Hybrid (configuration plus endpoint)
 
-Currently only configuration driven mode is implemented.
-
 ## Configuration-Driven Mode
 
-By default this service looks in a relative `model/Model-Extended.json` from the CWD
-for the schemas.
-
-Default configuration:
-
-```js
-	{
-		FullMeadowSchemaPath: `${process.cwd()}/model/`,
-		FullMeadowSchemaFilename: `Model-Extended.json`,
+The service looks for a `Retold` stanza in the configuration.  For instance:
 
-		DALMeadowSchemaPath: `${process.cwd()}/model/meadow/`,
-		DALMeadowSchemaPrefix: `Model-MeadowSchema-`,
-		DALMeadowSchemaPostfix: ``,
-
-		AutoStartOrator: true
-	})
+```
+{
+    ...
+    "Retold": {
+        "MeadowModel": "./meadow-schema-extended.json"
+    },
+    ...
+}
 ```
 
 The three auto-configured parameters are:

package/debug/Harness.js

@@ -3,51 +3,38 @@ const _Settings = require('./bookstore-configuration.json');
 const libFable = require('fable');
 
 _Fable = new libFable(_Settings);
-let libRetoldDataService = _Fable.serviceManager.addAndInstantiateServiceType('RetoldDataService', require('../source/Retold-Data-Service.js'));
 
-libRetoldDataService.onAfterInitializeAsync =
-    (fAfterInitializeComplete) =>
-    {
-        // Create a post operation behavior for the book Read singular record endpoint only
-        _Fable.MeadowEndpoints.Book.controller.BehaviorInjection.setBehavior('Read-PostOperation',
-            (pRequest, pRequestState, fRequestComplete) =>
-            {
-                // Get the join records
-                _Fable.DAL.BookAuthorJoin.doReads(_Fable.DAL.BookAuthorJoin.query.addFilter('IDBook', pRequestState.Record.IDBook),
-                    (pJoinReadError, pJoinReadQuery, pJoinRecords)=>
-                    {
-                        let tmpAuthorList = [];
-                        for (let j = 0; j < pJoinRecords.length; j++)
-                        {
-                            tmpAuthorList.push(pJoinRecords[j].IDAuthor);
-                        }
-                        if (tmpAuthorList.length < 1)
-                        {
-                            _Fable.log.trace(`Found no authors for IDBook ${pRequestState.Record.IDBook} (${pRequestState.Record.Title}).  What even is a book without authors?`)
-                            pRequestState.Record.Authors = [];
-                            return fRequestComplete();
-                        }
-                        else
-                        {
-                            _Fable.DAL.Author.doReads(_Fable.DAL.Author.query.addFilter('IDAuthor', tmpAuthorList, 'IN'),
-                                (pReadsError, pReadsQuery, pAuthors)=>
-                                {
-                                    pRequestState.Record.Authors = pAuthors;
-                                    _Fable.log.info(`Found ${pAuthors.length} authors for IDBook ${pRequestState.Record.IDBook} (${pRequestState.Record.Title}).`)
-                                    return fRequestComplete();
-                                });
-                        }
-                    });
-            });
+_Fable.serviceManager.addAndInstantiateServiceType('RetoldDataService', require('../source/Retold-Data-Service.js'));
 
-        return fAfterInitializeComplete();
-    };
-
-libRetoldDataService.initializeAsync(
-    (pError) =>
-    {
-        if (pError)
-        {
-            _Fable.log.error(`Error initializing `)
-        }
-    });
+_Fable.RetoldDataService.initializeService(
+	(pError) =>
+	{
+		_Fable.MeadowEndpoints.Book.controller.BehaviorInjection.setBehavior('Read-PostOperation',
+			(pRequest, pRequestState, fComplete) =>
+			{
+				// Get the join records
+				_Fable.DAL.BookAuthorJoin.doReads(_Fable.DAL.BookAuthorJoin.query.addFilter('IDBook', pRequestState.Record.IDBook),
+					(pJoinReadError, pJoinReadQuery, pJoinRecords)=>
+					{
+						let tmpAuthorList = [];
+						for (let j = 0; j < pJoinRecords.length; j++)
+						{
+							tmpAuthorList.push(pJoinRecords[j].IDAuthor);
+						}
+						if (tmpAuthorList.length < 1)
+						{
+							pRequestState.Record.Authors = [];
+							return fComplete();
+						}
+						else
+						{
+							_Fable.DAL.Author.doReads(_Fable.DAL.Author.query.addFilter('IDAuthor', tmpAuthorList, 'IN'),
+								(pReadsError, pReadsQuery, pAuthors)=>
+								{
+									pRequestState.Record.Authors = pAuthors;
+									return fComplete();
+								});
+						}
+					});
+			});
+	});

package/debug/bookstore-configuration.json

@@ -14,7 +14,7 @@
 			}
 		],
 
-	"APIServerPort": 7765,
+	"APIServerPort": 8087,
 
 	"MySQL":
 		{
@@ -25,5 +25,6 @@
 			"Database": "bookstore",
 			"ConnectionPoolLimit": 20
 		},
+
 	"MeadowConnectionMySQLAutoConnect": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "retold-data-service",
-    "version": "1.0.4",
+    "version": "2.0.1",
     "description": "Serve up a whole model!",
     "main": "source/Retold-Data-Service.js",
     "scripts": {
@@ -9,7 +9,7 @@
         "test": "./node_modules/.bin/mocha -u tdd -R spec",
         "build": "npx quack build",
         "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t retold-data-service-image:local",
-        "docker-dev-run": "docker run -it -d --name retold-data-service-dev -p 44444:8080 -p 43306:3306 -p 8086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/retold-data-service\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold-data-service-image:local",
+        "docker-dev-run": "docker run -it -d --name retold-data-service-dev -p 44444:8080 -p 43306:3306 -p 48086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/retold-data-service\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold-data-service-image:local",
         "docker-dev-shell": "docker exec -it retold-data-service-dev /bin/bash"
     },
     "mocha": {
@@ -46,14 +46,14 @@
     },
     "homepage": "https://github.com/stevenvelozo/retold-data-service",
     "devDependencies": {
-        "quackage": "^1.0.24"
+        "quackage": "^1.0.28"
     },
     "dependencies": {
-        "fable": "^3.0.96",
+        "fable": "^3.0.112",
         "fable-serviceproviderbase": "^3.0.12",
         "meadow": "^2.0.15",
         "meadow-connection-mysql": "^1.0.4",
-        "meadow-endpoints": "^4.0.2",
+        "meadow-endpoints": "^4.0.5",
         "orator": "^4.0.2",
         "orator-serviceserver-restify": "^2.0.2"
     }

package/source/Retold-Data-Service.js

@@ -9,6 +9,7 @@ const libFableServiceProviderBase = require('fable-serviceproviderbase');
 
 const libOrator = require('orator');
 const libOratorServiceServerRestify = require('orator-serviceserver-restify');
+
 const libMeadow = require('meadow');
 const libMeadowEndpoints = require('meadow-endpoints');
 
@@ -21,6 +22,7 @@ const defaultDataServiceSettings = (
 		DALMeadowSchemaPrefix: `Model-MeadowSchema-`,
 		DALMeadowSchemaPostfix: ``,
 
+		AutoInitializeDataService: true,
 		AutoStartOrator: true
 	});
 
@@ -33,169 +35,131 @@ class RetoldDataService extends libFableServiceProviderBase
         this.serviceType = 'RetoldDataService';
 
 		this.options = this.fable.Utility.extend(defaultDataServiceSettings, this.options);
+
+		// Add the restify server provider and orator base class to fable
+		this.fable.serviceManager.addServiceType('OratorServiceServer', libOratorServiceServerRestify);
+		this.fable.serviceManager.addServiceType('Orator', libOrator);
+
+		// Initialize Restify
+		this.fable.serviceManager.instantiateServiceProvider('OratorServiceServer', this.options);
+
+		// Initialize Orator, which will automatically use the default `OratorServiceServer` service we just instantiated
+		this.fable.serviceManager.instantiateServiceProvider('Orator', this.options);
+
+		// TODO: This code will be much cleaner with meadow and meadow-endpoints as services
+		this._Meadow = libMeadow.new(_Fable);
+
+		// Create DAL objects for each table in the schema
+		// These will be unnecessary when meadow and meadow-endpoints are full fledged fable services
+		this._DAL = {};
+		this._MeadowEndpoints = {};
+
+		// Decorate fable with the same -- this is a temporary hack until meadow and meadow-endpoints are full fledged fable services
+		this.fable.DAL = this._DAL;
+		this.fable.MeadowEndpoints = this._MeadowEndpoints;
+
+		// Storage for the model and entities
+		this.fullModel = false;
+		this.entityList = false;
+
+		this.serviceInitialized = false;
+	}
+
+	onBeforeInitialize(fCallback)
+	{
+		return fCallback();
+	}
+	onInitialize(fCallback)
+	{
+		return fCallback();
+	}
+	onAfterInitialize(fCallback)
+	{
+		return fCallback();
 	}
 
-	onBeforeInitializeAsync(fCallback)
+	initializePersistenceEngine(fCallback)
 	{
-		this.onBeforeInitialize();
+		// TODO: Change this to an option (e.g. we might want to do ALASQL)
+		// Load the mysql connection for meadow if it doesn't exist yet
+		this.fable.serviceManager.addAndInstantiateServiceType('MeadowMySQLProvider', require('meadow-connection-mysql'));
 		return fCallback();
 	}
-	onBeforeInitialize()
+	initializeDataEndpoints(fCallback)
 	{
-		this.log.info("Retold Data Service Application is beginning initialization...");
+		this.fable.log.info("Retold Data Service initializing Endpoints...");
+
+		// Create DAL objects for each table in the schema
+
+		// 1. Load full compiled schema of the model from stricture
+		_Fable.log.info(`...loading full model stricture schema...`);
+		this.fullModel = require (`${this.options.FullMeadowSchemaPath}${this.options.FullMeadowSchemaFilename}`);
+		_Fable.log.info(`...full model stricture schema loaded.`);
+
+		// 2. Extract an array of each table in the schema
+		_Fable.log.info(`...getting entity list...`);
+		this.entityList = Object.keys(this.fullModel.Tables);
+
+		// 3. Enumerate each entry in the compiled model and load a DAL for that table
+		_Fable.log.info(`...initializing ${this.entityList.length} DAL objects and corresponding Meadow Endpoints...`);
+		for (let i = 0; i < this.entityList.length; i++)
+		{
+			// 4. Create the DAL for each entry (e.g. it would be at _DAL.Movie for the Movie entity)
+			let tmpDALEntityName = this.entityList[i];
+			let tmpDALPackageFile = `${this.options.DALMeadowSchemaPath}${this.options.DALMeadowSchemaPrefix}${tmpDALEntityName}${this.options.DALMeadowSchemaPostfix}.json`
+			_Fable.log.info(`Initializing the ${tmpDALEntityName} DAL from [${tmpDALPackageFile}]...`);
+			this._DAL[tmpDALEntityName] = this._Meadow.loadFromPackage(tmpDALPackageFile);
+			// 5. Tell this DAL object to use MySQL
+			_Fable.log.info(`...defaulting the ${tmpDALEntityName} DAL to use MySQL`);
+			this._DAL[tmpDALEntityName].setProvider('MySQL');
+			// 6. Create a Meadow Endpoints class for this DAL
+			_Fable.log.info(`...initializing the ${tmpDALEntityName} Meadow Endpoints to use MySQL`);
+			this._MeadowEndpoints[tmpDALEntityName] = libMeadowEndpoints.new(this._DAL[tmpDALEntityName]);
+			// 8. Expose the meadow endpoints on Orator
+			_Fable.log.info(`...mapping the ${tmpDALEntityName} Meadow Endpoints to Orator`);
+			this._MeadowEndpoints[tmpDALEntityName].connectRoutes(this.fable.Orator.webServer);
+		}
+
+		return fCallback();
 	}
 
-	initializeAsync(fCallback)
+	initializeService(fCallback)
 	{
 		if (this.serviceInitialized)
 		{
-			this.fable.log.error("Retold Data Service Application is being initialized but has already been initialized...");
+			return fCallback(new Error("Retold Data Service Application is being initialized but has already been initialized..."));
 		}
 		else
 		{
-			let tmpAnticipate = this.fable.instantiateServiceProviderWithoutRegistration('Anticipate');
-			// Phase I:   Allow the API host to inject behavior before anything magic happens.
-			tmpAnticipate.anticipate(this.onBeforeInitializeAsync.bind(this));
-			// Phase II:  Make sure there is an Orator server available so we can put the behaviors somewhere
-			tmpAnticipate.anticipate(
-				function (fCallback)
-				{
-					// Check if Fable already has an Orator service provider, otherwise add one.
-					if (!this.fable.serviceClasses.hasOwnProperty('OratorServiceServer'))
-					{
-						this.fable.serviceManager.addAndInstantiateServiceType('OratorServiceServer', libOratorServiceServerRestify, this.fable.settings);
-					}
-					else if (!this.fable.OratorServiceServer)
-					{
-						this.fable.serviceManager.instantiateServiceProvider('OratorServiceServer', this.fable.settings);
-					}
-					return fCallback();
-				}.bind(this));
-			tmpAnticipate.anticipate(
-				function (fCallback)
-				{
-					// Check if Fable already has an Orator service provider, otherwise add one.
-					if (!this.fable.serviceClasses.hasOwnProperty('Orator'))
-					{
-						this.fable.serviceManager.addAndInstantiateServiceType('Orator', libOrator, this.fable.settings);
-					}
-					else if (!this.fable.Orator)
-					{
-						this.fable.serviceManager.instantiateServiceProvider('Orator', this.fable.settings);
-					}
-					return fCallback();
-				}.bind(this));
-			// Phase III: Initialize orator
-			tmpAnticipate.anticipate(this.fable.Orator.initialize.bind(this.fable.Orator));
-			// Phase IV:  Initialize Meadow (this will simplify greatly when meadow and meadow-endpoints are service-ized)
-			tmpAnticipate.anticipate(		
-				function (fCallback)
-				{
-					// TODO: This code will be much cleaner with meadow and meadow-endpoints as a service.  They are the only toolchain that is left!
-					this._Meadow = libMeadow.new(_Fable);
+			let tmpAnticipate = this.fable.newAnticipate();
 
-					// Create DAL objects for each table in the schema
-					// These will be unnecessary when meadow and meadow-endpoints are full fledged fable services and then 
-					// refactored to auto-initialize on a schema provider.
-					// For now, this is a mock of how we expect that service to provide interfaces to DAL objects.
-					this._DAL = {};
-					this.fable.DAL = this._DAL;
-					// And a mock of how the endpoints will be expressed.
-					this._MeadowEndpoints = {};
-					this.fable.MeadowEndpoints = this._MeadowEndpoints;
+			this.fable.log.info(`The Retold Data Service is Auto Starting Orator`);
 
-					// TODO: This goes away when the above use services in a sane fashion.
-					// Load the mysql connection for meadow if it doesn't exist yet
-					_Fable.serviceManager.addAndInstantiateServiceType('MeadowMySQLProvider', require('meadow-connection-mysql'));
+			tmpAnticipate.anticipate(this.onBeforeInitialize.bind(this));
 
-					this.fullModel = false;
-					this.entityList = false;
+			tmpAnticipate.anticipate(this.fable.Orator.startWebServer.bind(this.fable.Orator));
+			tmpAnticipate.anticipate(this.initializePersistenceEngine.bind(this));
 
-					this.serviceInitialized = false;
+			tmpAnticipate.anticipate(this.onInitialize.bind(this));
 
-					return fCallback();
-				}.bind(this));
-			// Phase V:  Initialize the meat of the matter (the retold data service)
-			tmpAnticipate.anticipate(
-				function(fCallback)
-				{
-					this.fable.log.info("Retold Data Service DAL methods initializing...");
-
-					// Create DAL objects for each table in the schema
-					// 1. Load full compiled schema of the model from stricture
-					_Fable.log.info(`...loading full model stricture schema...`);
-					this.fullModel = require (`${this.options.FullMeadowSchemaPath}${this.options.FullMeadowSchemaFilename}`);
-					_Fable.log.info(`...full model stricture schema loaded.`);
-
-					// 2. Extract an array of each table in the schema
-					_Fable.log.info(`...getting entity list...`);
-					this.entityList = Object.keys(this.fullModel.Tables);
+			tmpAnticipate.anticipate(this.initializeDataEndpoints.bind(this));
 
-					// 3. Enumerate each entry in the compiled model and load a DAL for that table
-					_Fable.log.info(`...initializing ${this.entityList.length} DAL objects and corresponding Meadow Endpoints...`);
-					for (let i = 0; i < this.entityList.length; i++)
-					{
-						// 4. Create the DAL for each entry (e.g. it would be at _DAL.Movie for the Movie entity)
-						let tmpDALEntityName = this.entityList[i];
-						let tmpDALPackageFile = `${this.options.DALMeadowSchemaPath}${this.options.DALMeadowSchemaPrefix}${tmpDALEntityName}${this.options.DALMeadowSchemaPostfix}.json`
-						_Fable.log.info(`Initializing the ${tmpDALEntityName} DAL from [${tmpDALPackageFile}]...`);
-						this._DAL[tmpDALEntityName] = this._Meadow.loadFromPackage(tmpDALPackageFile);
-						// 5. Tell this DAL object to use MySQL
-						_Fable.log.info(`...defaulting the ${tmpDALEntityName} DAL to use MySQL`);
-						this._DAL[tmpDALEntityName].setProvider('MySQL');
-						// 6. Create a Meadow Endpoints class for this DAL
-						_Fable.log.info(`...initializing the ${tmpDALEntityName} Meadow Endpoints to use MySQL`);
-						this._MeadowEndpoints[tmpDALEntityName] = libMeadowEndpoints.new(this._DAL[tmpDALEntityName]);
-						// 8. Expose the meadow endpoints on Orator
-						_Fable.log.info(`...mapping the ${tmpDALEntityName} Meadow Endpoints to Orator`);
-						this._MeadowEndpoints[tmpDALEntityName].connectRoutes(this.fable.Orator.webServer);
-					}
-
-					this.serviceInitialized = true;
+			tmpAnticipate.anticipate(this.onAfterInitialize.bind(this));
 
-					return fCallback();
-				}.bind(this));
-			// Phase VI:  Optionally auto start the orator server.
-			tmpAnticipate.anticipate(
-				function (fCallback)
-				{
-					if (this.options.AutoStartOrator)
-					{
-						this.fable.log.info(`The Retold Data Service is Auto Starting Orator...`);
-						this.fable.Orator.startWebServer(fCallback);
-					}
-					else
-					{
-						return fCallback();
-					}
-				}.bind(this));
-			tmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));
-
-			// Now anticipate (wait for) initialization to complete.
 			tmpAnticipate.wait(
-				function (pError)
+				(pError)=>
 				{
 					if (pError)
 					{
-						let tmpErrorMessage = `Error initializing Retold Data Service: ${pError}`;
-						this.log.error(tmpErrorMessage);
-						// TODO: Should this bubble up?  I think not.
-						throw new Error(tmpErrorMessage);
+						this.log.error(`Error initializing Retold Data Service: ${pError}`);
+						return fCallback(pError);
 					}
+
+					this.serviceInitialized = true;
 					return fCallback();
-				}.bind(this));
+				});
 		}
 	}
-
-	onAfterInitializeAsync(fCallback)
-	{
-		this.onAfterInitialize();
-		return fCallback();
-	}
-	onAfterInitialize()
-	{
-		this.log.info("Retold Data Service Application has completed an initialization attempt.");
-	}
 }
 
 module.exports = RetoldDataService;

package/test/RetoldDataService_tests.js

@@ -8,6 +8,7 @@
 
 var Chai = require("chai");
 var Expect = Chai.expect;
+var Assert = Chai.assert;
 
 const libFable = require('fable');
 
@@ -41,13 +42,9 @@ suite
 								AutoStartOrator: true
 							});
 
-						Expect(tmpRetoldDataService).to.be.an('object', 'Retold Data Service should initialize as an object.');
+						tmpRetoldDataService.initializeService();
 
-						tmpRetoldDataService.initializeAsync(
-							function(pError)
-							{
-								return fDone();
-							});
+						return fDone();
 					}
 				);
 			}

package/test/model/fable-configuration.json

@@ -1,7 +1,7 @@
 {
 	"Product": "MeadowEndpointsTest",
 
-	"APIServerPort": 7764,
+	"APIServerPort": 8088,
 
 	"MySQL":
 		{