retold-data-service 1.0.2 → 1.0.3

package/debug/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "retold-harness",
+  "version": "1.0.0",
+  "description": "Harness data import and server.",
+  "main": "bookstore-serve-meadow-endpoints-apis.js",
+  "scripts": {
+    "start": "node bookstore-serve-meadow-endpoint-apis-run.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "MIT",
+  "dependencies": {}
+}

package/package.json

@@ -1,13 +1,35 @@
 {
   "name": "retold-data-service",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Serve up a whole model!",
   "main": "source/Retold-Data-Service.js",
   "scripts": {
     "start": "node source/Retold-Data-Service.js",
-    "coverage": "./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
-    "test": "./node_modules/mocha/bin/_mocha -u tdd -R spec",
-    "harness": "node debug/Harness.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",
+    "build": "./node_modules/.bin/gulp build",
+    "build-compatible": "GULP_CUSTOM_BUILD_TARGET=compatible ./node_modules/.bin/gulp build",
+    "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t retold/retold-data-service:local",
+    "docker-dev-run": "docker run -it -d --name retold-retold-data-service-dev -p 44444:8080 -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/retold-data-service:local",
+    "docker-dev-shell": "docker exec -it retold-retold-data-service-dev /bin/bash"
+  },
+  "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",
@@ -24,20 +46,28 @@
   },
   "homepage": "https://github.com/stevenvelozo/retold-data-service",
   "devDependencies": {
-    "chai": "3.5.0",
-    "coveralls": "2.13.1",
-    "istanbul": "0.4.5",
-    "mocha": "3.4.1"
+    "@babel/core": "^7.21.8",
+    "@babel/preset-env": "^7.21.5",
+    "browserify": "^17.0.0",
+    "chai": "4.3.7",
+    "gulp": "^4.0.2",
+    "gulp-babel": "^8.0.0",
+    "gulp-env": "^0.4.0",
+    "gulp-sourcemaps": "^3.0.0",
+    "gulp-terser": "^2.1.0",
+    "gulp-util": "^3.0.8",
+    "mocha": "10.2.0",
+    "nyc": "^15.1.0",
+    "vinyl-buffer": "^1.0.1",
+    "vinyl-source-stream": "^2.0.0"
   },
   "dependencies": {
-    "async": "^3.2.3",
-    "cookie": "^0.5.0",
-    "fable": "^2.0.5",
-    "meadow-endpoints": "^3.0.2",
-    "orator": "^2.0.4",
-    "restify": "^8.6.1",
-    "simple-get": "^4.0.1",
-    "underscore": "^1.13.2",
-    "mysql2": "1.2.0"
+    "fable": "^3.0.46",
+    "fable-serviceproviderbase": "^3.0.4",
+    "meadow": "^2.0.5",
+    "meadow-connection-mysql": "^1.0.2",
+    "meadow-endpoints": "^4.0.2",
+    "orator": "^3.0.11",
+    "orator-serviceserver-restify": "^1.0.4"
   }
 }

package/source/Retold-Data-Service.js

@@ -1,336 +1,131 @@
-// ##### Part of the **[retold](https://stevenvelozo.github.io/retold/)** system
 /**
-* @license MIT
-* @author <steven@velozo.com>
-*/
-const libAsync = require('async');
+ * Retold Data Service
+ * 
+ * All-in-one add-ins for fable to provide endpoints.
+ *
+ * @author Steven Velozo <steven@velozo.com>
+ */
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
 const libOrator = require('orator');
 const libMeadow = require('meadow');
 const libMeadowEndpoints = require('meadow-endpoints');
 
-const libProviderBase = require('./ProviderHelpers/Meadow-Provider-Helper-Base.js');
-
-const libGraphSolver = require('./GraphGet.js');
-const libCumulation = require('./Cumulation.js');
-/**
-* Retold Data Service
-* 
-* Load all schemas from a model, and serve up the endpoints.  Provide join autofills, graph 
-* solver and other data niceties.
-* 
-* Configuration stanza expectation:
-RetoldDataService: {
-	SchemaFile: 'SchemaFileLocation',
-	-- OR --
-	Schema: [{ ... schemas in here ... }, { ... more schemas ... }],
-
-	AutoLoad: true,
-
-	MapExtraEndpoints: true,
-
-	SchemaGraphEndpoint: 'SchemaGraph'
-}
+const defaultDataServiceSettings = (
+	{
+		FullMeadowSchemaPath: `${process.cwd()}/model/`,
+		FullMeadowSchemaFilename: `Model-Extended.json`,
+		
+		DALMeadowSchemaPath: `${process.cwd()}/model/meadow/`,
+		DALMeadowSchemaPrefix: `Model-MeadowSchema-`,
+		DALMeadowSchemaPostfix: ``,
 
+		AutoInitializeDataService: true,
+		AutoStartOrator: true
+	});
 
-* The first four settings are very obvious what they do.  The last one is the endpoint that
-* serves the entire schema graph.
-* 
-*
-* @class RetoldDataService
-*/
-class RetoldDataService
+class RetoldDataService extends libFableServiceProviderBase
 {
-	constructor(pConfiguration)
+	constructor(pFable, pManifest, pServiceHash)
 	{
-		let tmpConfiguration = (typeof(pConfiguration) === 'object') ? pConfiguration : {};
-
-		this._Orator = libOrator.new(tmpConfiguration);
-
-		this._Fable = this._Orator.fable;
-		this._Settings = this._Fable.settings;
+		super(pFable, pManifest, pServiceHash);
 
-		this._Meadow = libMeadow.new(this._Fable);
-		this._MeadowModelGraph = {};
+        this.serviceType = 'RetoldDataService';
 
-		this._DAL = {};
-		this._MeadowEndpoints = {};
+		this.options = this.fable.Utility.extend(defaultDataServiceSettings, this.options);
 
-		this._Providers = {};
+		// TODO: Check if Fable already has an Orator service provider, otherwise add one.
+		// TODO: First switch the new Orator to the new service provider pattern
+		// TODO: Make the restify/http stuff optional, so IPC works.
+		// Orator is the (usually web) server
+		this.fable.Orator = new libOrator(this.fable, require('orator-serviceserver-restify'));
 
-		this._GraphSolver = false;
-
-		this.log = this._Fable.log;
-
-		// Load the configurations
-		if (this._Settings.hasOwnProperty('Retold'))
+		// Because this requires the callback, we will have to add better plumbing for these services to initialie
+		this.fable.Orator.initializeServiceServer(() =>
 		{
-			if (this._Settings.Retold.hasOwnProperty('MeadowModel'))
-			{
-				// One or many full Model file path(s) has been set
-				this._Settings.Retold.MeadowModel = `${process.cwd()}/model/MeadowModel.json`;
-			}
-			
-			if (this._Settings.Retold.hasOwnProperty('MeadowEntitySchemaPrefix'))
-			{
-				// One or many Entity Schema file path(s) is set
-				this._Settings.Retold.MeadowEntitySchemaPrefix = `${process.cwd()}/model/meadow/MeadowSchema`;
-			}
-		}
-		else
-		{
-			// Create a retold entry with defaults
-			this._Settings.Retold = (
-			{
-				// This setting will automatically load the model
-				"AutoLoadModel": true,
-				// This setting will automatically connect the provider via the helper
-				// (e.g. connect to MySQL)
-				"AutoConnectProvider": true,
-				// This setting will automatically connect the backplane endpoints
-				"AutoMapBackplaneEndpoints": true,
-				// This setting will automatically map the entity endpoints when entities are loaded
-				"AutoMapEntityEndpoints": true,
-				// This setting autostarts the orator server
-				"AutoStartAPIServer": true,
+			// TODO: This code will be much cleaner with these as services
+			this._Meadow = libMeadow.new(_Fable);
 
-				// These allow the deeper behaviors of the provider helpers (e.g. creating tables)
-				"AllowDatabaseCreate": false,
-				"AllowTableCreate": false,
-				"AllowTableUpdate": false,
+			// 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.fable.DAL = this._DAL;
+			this._MeadowEndpoints = {};
+			this.fable.MeadowEndpoints = this._MeadowEndpoints;
 
-				// This will never work because the base provider just uses English.
-				// Maybe switch to ALASQL by default for stateless services.
-				"DefaultMeadowDataProvider": "Base",
+			// 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
+			_Fable.serviceManager.addAndInstantiateServiceType('MeadowMySQLProvider', require('meadow-connection-mysql'));
 
-				// Either the Meadow side or Stricture side should be set.
-				// Try to use the opinionated Stricture locations if they arent (you really should set this though!)
-				"MeadowModel": `${process.cwd()}/model/MeadowModel.json`,
-				"MeadowEntitySchemaPrefix": `${process.cwd()}/model/meadow/MeadowSchema`,
+			this.fullModel = false;
+			this.entityList = false;
 
-				"StrictureDDL": false
-			});
-		}
+			this.serviceInitialized = false;
 
-		this.initialize();
-	}
-
-	initialize(fCallback)
-	{
-		let tmpCallback = (typeof(fCallback) == 'function') ? fCallback : ()=>{};
-		libAsync.waterfall(
-			[
-				(fStageComplete) =>
-				{
-					if (this._Settings.Retold.AutoLoadModel)
-					{
-						this.loadModels();
-					}
-
-					return fStageComplete();
-				},
-				(fStageComplete) =>
-				{
-					if (this._Settings.Retold.AutoConnectProvider)
-					{
-						this.initializeDefaultProvider();					
-					}
-					return fStageComplete();
-				},
-				(fStageComplete) =>
-				{
-					if (this._Settings.Retold.AutoMapBackplaneEndpoints)
-					{
-						this.mapBackplaneEndpoints();
-					}
-
-					return fStageComplete();
-				},
-				(fStageComplete) =>
-				{
-					// Initialize the graph solver library
-					this.initializeGraphEndpoints();
-					// Map the graph endpoints to it
-					// TODO: Decide if this follows the Meadow pattern or some other prefix pattern
-					this._Orator.webServer.post(`/1.0/GraphRead/:Entity`,
-						(pRequest, pResponse, fNext) =>
-						{
-							let tmpGraphRequestEntity = pRequest.params.Entity;
-							let tmpGraphRequestFilter = pRequest.body;
-
-							// TODO: Discuss how to pass in request settings -- what was in there worked for the web client and works for tokens so maybe it's okay?
-							let tmpCumulation = new libCumulation(this._Fable, {});
-
-							this._GraphSolver.get(tmpGraphRequestEntity, tmpGraphRequestFilter, tmpCumulation,
-								(pError, pRecords, pValidFilters, pFinalFilters, pJoinedDataSets, pValidIdentities) =>
-								{
-									pResponse.send(
-										{
-											GraphRequestEntity: tmpGraphRequestEntity,
-											GraphRequestFilter: tmpGraphRequestFilter,
-
-											Records: pRecords,
-
-											ValidFilters: pValidFilters,
-											Finalfilters: pFinalFilters,
-
-											JoinedDataSets: pJoinedDataSets,
-											ValidIdentities: pValidIdentities,
-
-											Error: pError
-										});
-									return fNext();		
-								});
-						});
-		
-					return fStageComplete();
-				},
-				(fStageComplete) =>
-				{
-					if (this._Settings.Retold.AutoStartAPIServer)
-					{
-						this.start(fStageComplete);
-					}
-					else
-					{
-						return fStageComplete();
-					}
-				}
-			],
-			(pError)=>
+			if (this.options.AutoInitializeDataService)
 			{
-				if (pError)
-				{
-					this._Fable.log.error('Error initializing Retold Data Service: '+pError.toString(), pError);
-				}
-
-				tmpCallback(pError);
-			});
-	}
-
-	initializeDefaultProvider()
-	{
-		let libProvider = require(`./ProviderHelpers/Meadow-Provider-Helper-${this._Settings.Retold.DefaultMeadowDataProvider}.js`);
-		
-		// This is to support multiple providers
-		this._Providers.Default = new libProvider(this._Fable);
-		
-		return this._Providers.Default.connect();
-	}
-
-	initializeGraphEndpoints()
-	{
-		this._GraphSolver = new libGraphSolver(this._Fable, this._MeadowModelGraph);
-	}
-
-	mapBackplaneEndpoints()
-	{
-		const tmpBackplanePrefix = 'BACKPLANE';
-		// Pull version from the config file.
-		const tmpEndpointVersion = this._Fable.settings.MeadowEndpointVersion || '1.0';
-
-		const tmpBackplaneEndpointPrefix = `/${tmpBackplanePrefix}/${tmpEndpointVersion}`;
+				this.fable.log.info(`The Retold Data Service is Auto Initializing itself`);
+				this.initializeService();
+			}
 
-		// TODO: Break this out into separate classes
-		this._Orator.webServer.get(`${tmpBackplaneEndpointPrefix}/Model`,
-			(pRequest, pResponse, fNext) =>
+			if (this.options.AutoStartOrator)
 			{
-				pResponse.send(this._MeadowModelGraph);
-				return fNext();
-			});
+				this.fable.log.info(`The Retold Data Service is Auto Starting Orator`);
+				this.fable.Orator.startWebServer(
+					(pError) =>
+					{
+						if (pError)
+						{
+							console.log(`Error auto-starting Orator: ${pError}`, pError);
+						}
+					});
+			}
+		});
 	}
 
-	// Lock the service to a specific session (this will bypass auth)
-	lockServiceSession(pSessionData)
+	initializeService()
 	{
-		if (typeof(pSessionData) != 'object')
+		if (this.serviceInitialized)
 		{
-			this.log.error(`Error locking service session -- invalid object passed in.`, pSessionData);
-			return false;
+			this.fable.log.error("Retold Data Service Application is being initialized but has already been initialized...");
 		}
-
-		_Fable.log.info(`...Creating Mock User Session and adding it to all requests on Restify/Orator`, pSessionData);
-		var fMockAuthentication = (pRequest, pResponse, fNext) =>
+		else
 		{
-			pRequest.UserSession = pSessionData;
-			fNext();
-		};
-		this._Orator.webServer.use(fMockAuthentication);
-	}
+			this.fable.log.info("Retold Data Service Application is starting up...");
 
-	// Load models based on what's in the configuration
-	loadModels()
-	{
-		if (this._Settings.Retold.MeadowModel)
-		{
-			this.loadMeadowModelFile(this._Settings.Retold.MeadowModel);
-		}
-	}
+			// Create DAL objects for each table in the schema
 
-	loadMeadowModelFile(pModelFilePath)
-	{
-		// TODO: Wrap this in a try/catch/finally
-		this._MeadowModelGraph = require(pModelFilePath);
-		this.loadMeadowModel(this._MeadowModelGraph);
-	}
+			// 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.`);
 
-	loadMeadowModel(pModelObject)
-	{
-		// Create DAL objects for each table in the schema
-		// 1. Validate the model object
-		if (typeof(pModelObject) !== 'object')
-		{
-			this.log.error(`Could not load Meadow model object: Invalid object passed.`, pModelObject);
-			return false;
-		}
-		if (!pModelObject.hasOwnProperty('Tables')
-			|| typeof(pModelObject.Tables) != 'object')
-		{
-			this.log.error(`Could not load Meadow model object: Object does not contain a Tables property.`, pModelObject);
-			return false;
-		}
-		// 2. Extract an array of each table in the schema
-		let tmpModelTableList = Object.keys(pModelObject.Tables);
-		let tmpDefaultProvider = (this._Fable.settings.Retold.DefaultMeadowDataProvider) ? this._Fable.settings.Retold.DefaultMeadowDataProvider : 'Base';
-		// 3. Enumerate each entry in the compiled model and load a DAL for that table
-		this.log.info(`...Creating ${tmpModelTableList.length} DAL entries...`);
-		for (let i = 0; i < tmpModelTableList.length; i++)
-		{
-			let tmpDALEntityName = tmpModelTableList[i];
-			this.log.info(`   -> Creating the [${tmpDALEntityName}] DAL...`);
-			// 4. Create the DAL for each entry (e.g. it would be at _DAL.Book or _DAL.Author)
-			// TODO: I don't like this ... stricture should just generate a huge file of these in an array, which could be loaded with the new injector
-			this._DAL[tmpDALEntityName] = this._Meadow.loadFromPackage(`${this._Settings.Retold.MeadowEntitySchemaPrefix}${tmpDALEntityName}.json`);
-			// 5. Tell this DAL object to use the default provider
-			this._DAL[tmpDALEntityName].setProvider(tmpDefaultProvider);
-			// 6. Create a Meadow Endpoints class for this DAL
-			this._MeadowEndpoints[tmpDALEntityName] = libMeadowEndpoints.new(this._DAL[tmpDALEntityName]);
-			// 7. Expose the meadow endpoints on Orator
-			if (this._Fable.settings.Retold.AutoMapEntityEndpoints)
+			// 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++)
 			{
-				this._MeadowEndpoints[tmpDALEntityName].connectRoutes(this._Orator.webServer);
-				this._MeadowEndpoints[tmpDALEntityName].RoutesConnected = true;
+				// 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);
 			}
-		}
-	}
 
-	start(fCallback)
-	{
-		this._Orator.startWebServer(fCallback);
-	}
-
-	get orator()
-	{
-		return this._Orator;
-	}
-
-	get fable()
-	{
-		return this._Fable;
-	}
-
-	get settings()
-	{
-		return this._Fable.settings;
+			this.serviceInitialized = true;
+		}
 	}
 }
 

package/test/RetoldDataService_tests.js

@@ -10,7 +10,9 @@ var Chai = require("chai");
 var Expect = Chai.expect;
 var Assert = Chai.assert;
 
-var libRetoldDataService = require('../source/Retold-Data-Service.js');
+const libFable = require('fable');
+
+const _Settings = require(`./model/fable-configuration.json`);
 
 suite
 (
@@ -24,47 +26,25 @@ suite
 			'Object Sanity',
 			function()
 			{
-				test
-				(
-					'The class should initialize itself into a happy little object.',
-					function()
-					{
-						testService = new libRetoldDataService({"Product":"SimpleInitializationTest"});
-
-						// Instantiate the logger
-						Expect(testService).to.be.an('object', 'The data service should initialize as an object directly from the require statement and minimal configuration.');
-						Expect(testService).to.have.a.property('log')
-							.that.is.a('object');
-						Expect(testService).to.have.a.property('settings')
-							.that.is.a('object');
-						Expect(testService).to.have.a.property('fable')
-							.that.is.a('object');
-						Expect(testService).to.have.a.property('orator')
-							.that.is.a('object');
-						Expect(testService.settings.Product)
-							.to.equal('SimpleInitializationTest')
-					}
-				);
 				test
 				(
 					'Change some settings later...',
 					function(fDone)
 					{
-						testService = new libRetoldDataService({"Product":"SimpleSettingsTest"});
+						_Fable = new libFable(_Settings);
+						_Fable.serviceManager.addServiceType('RetoldDataService', require('../source/Retold-Data-Service.js'));
+						let tmpRetoldDataService = _Fable.serviceManager.instantiateServiceProvider('RetoldDataService',
+							{
+								FullMeadowSchemaPath: `${process.cwd()}/test/model/`,
+								DALMeadowSchemaPath: `${process.cwd()}/test/model/meadow/`,
+						
+								AutoInitializeDataService: true,
+								AutoStartOrator: true
+							});
+
+						tmpRetoldDataService.initializeService();
 
-						Expect(testService).to.have.a.property('settings')
-							.that.is.a('object');
-						Expect(testService.settings.Product)
-							.to.equal('SimpleSettingsTest');
-						Expect(testService.settings.ProductVersion)
-							.to.equal('0.0.0');
-						// Now change a setting by merging in something new
-						testService.fable.settingsManager.merge({Product:'TestProduct'});
-						Expect(testService.settings.Product)
-							.to.equal('TestProduct');
-						Expect(testService.settings.ProductVersion)
-							.to.equal('0.0.0');
-						fDone();
+						return fDone();
 					}
 				);
 			}

package/test/model/fable-configuration.json

@@ -0,0 +1,16 @@
+{
+	"Product": "MeadowEndpointsTest",
+
+	"APIServerPort": 8088,
+
+	"MySQL":
+		{
+			"Server": "127.0.0.1",
+			"Port": 3306,
+			"User": "root",
+			"Password": "123456789",
+			"Database": "bookstore",
+			"ConnectionPoolLimit": 20
+		},
+	"MeadowConnectionMySQLAutoConnect": true
+}

package/test/model/meadow/README.md

@@ -0,0 +1 @@
+This is where the meadow schema for each table of the data model will generate.

package/debug/Build-Database.sh

@@ -1,12 +0,0 @@
-#! /bin/bash
-echo "Example - Database Build Script"
-echo "Contact: Steven Velozo <steven@velozo.com>"
-echo ""
-echo "---"
-echo ""
-
-echo "--> Stricture now generates everything automatically"
-echo "--> It loads from ./Model.ddl if no parameters are passed"
-npx stricture
-
-echo "--> Database Code generation and compilation complete!"