retold-data-service 1.0.2 → 1.0.4

package/package.json

@@ -1,43 +1,60 @@
 {
-  "name": "retold-data-service",
-  "version": "1.0.2",
-  "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"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/stevenvelozo/retold-data-service.git"
-  },
-  "keywords": [
-    "entity",
-    "behavior"
-  ],
-  "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/stevenvelozo/retold-data-service/issues"
-  },
-  "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"
-  },
-  "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"
-  }
+    "name": "retold-data-service",
+    "version": "1.0.4",
+    "description": "Serve up a whole model!",
+    "main": "source/Retold-Data-Service.js",
+    "scripts": {
+        "start": "node source/Retold-Data-Service.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": "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-shell": "docker exec -it 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",
+        "url": "https://github.com/stevenvelozo/retold-data-service.git"
+    },
+    "keywords": [
+        "entity",
+        "behavior",
+        "api"
+    ],
+    "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/stevenvelozo/retold-data-service/issues"
+    },
+    "homepage": "https://github.com/stevenvelozo/retold-data-service",
+    "devDependencies": {
+        "quackage": "^1.0.24"
+    },
+    "dependencies": {
+        "fable": "^3.0.96",
+        "fable-serviceproviderbase": "^3.0.12",
+        "meadow": "^2.0.15",
+        "meadow-connection-mysql": "^1.0.4",
+        "meadow-endpoints": "^4.0.2",
+        "orator": "^4.0.2",
+        "orator-serviceserver-restify": "^2.0.2"
+    }
 }

package/source/Retold-Data-Service.js

@@ -1,336 +1,200 @@
-// ##### 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 libOratorServiceServerRestify = require('orator-serviceserver-restify');
 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,
+const defaultDataServiceSettings = (
+	{
+		FullMeadowSchemaPath: `${process.cwd()}/model/`,
+		FullMeadowSchemaFilename: `Model-Extended.json`,
 
-	SchemaGraphEndpoint: 'SchemaGraph'
-}
+		DALMeadowSchemaPath: `${process.cwd()}/model/meadow/`,
+		DALMeadowSchemaPrefix: `Model-MeadowSchema-`,
+		DALMeadowSchemaPostfix: ``,
 
+		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;
-
-		this._Meadow = libMeadow.new(this._Fable);
-		this._MeadowModelGraph = {};
+		super(pFable, pManifest, pServiceHash);
 
-		this._DAL = {};
-		this._MeadowEndpoints = {};
+        this.serviceType = 'RetoldDataService';
 
-		this._Providers = {};
-
-		this._GraphSolver = false;
+		this.options = this.fable.Utility.extend(defaultDataServiceSettings, this.options);
+	}
 
-		this.log = this._Fable.log;
+	onBeforeInitializeAsync(fCallback)
+	{
+		this.onBeforeInitialize();
+		return fCallback();
+	}
+	onBeforeInitialize()
+	{
+		this.log.info("Retold Data Service Application is beginning initialization...");
+	}
 
-		// Load the configurations
-		if (this._Settings.hasOwnProperty('Retold'))
+	initializeAsync(fCallback)
+	{
+		if (this.serviceInitialized)
 		{
-			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`;
-			}
+			this.fable.log.error("Retold Data Service Application is being initialized but has already been initialized...");
 		}
 		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,
-
-				// These allow the deeper behaviors of the provider helpers (e.g. creating tables)
-				"AllowDatabaseCreate": false,
-				"AllowTableCreate": false,
-				"AllowTableUpdate": false,
-
-				// This will never work because the base provider just uses English.
-				// Maybe switch to ALASQL by default for stateless services.
-				"DefaultMeadowDataProvider": "Base",
-
-				// 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`,
-
-				"StrictureDDL": false
-			});
-		}
-
-		this.initialize();
-	}
-
-	initialize(fCallback)
-	{
-		let tmpCallback = (typeof(fCallback) == 'function') ? fCallback : ()=>{};
-		libAsync.waterfall(
-			[
-				(fStageComplete) =>
+			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)
 				{
-					if (this._Settings.Retold.AutoLoadModel)
+					// Check if Fable already has an Orator service provider, otherwise add one.
+					if (!this.fable.serviceClasses.hasOwnProperty('OratorServiceServer'))
 					{
-						this.loadModels();
+						this.fable.serviceManager.addAndInstantiateServiceType('OratorServiceServer', libOratorServiceServerRestify, this.fable.settings);
 					}
-
-					return fStageComplete();
-				},
-				(fStageComplete) =>
-				{
-					if (this._Settings.Retold.AutoConnectProvider)
+					else if (!this.fable.OratorServiceServer)
 					{
-						this.initializeDefaultProvider();					
+						this.fable.serviceManager.instantiateServiceProvider('OratorServiceServer', this.fable.settings);
 					}
-					return fStageComplete();
-				},
-				(fStageComplete) =>
+					return fCallback();
+				}.bind(this));
+			tmpAnticipate.anticipate(
+				function (fCallback)
 				{
-					if (this._Settings.Retold.AutoMapBackplaneEndpoints)
+					// Check if Fable already has an Orator service provider, otherwise add one.
+					if (!this.fable.serviceClasses.hasOwnProperty('Orator'))
 					{
-						this.mapBackplaneEndpoints();
+						this.fable.serviceManager.addAndInstantiateServiceType('Orator', libOrator, this.fable.settings);
 					}
-
-					return fStageComplete();
-				},
-				(fStageComplete) =>
+					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)
 				{
-					// 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, {});
+					// 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);
+
+					// 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;
+
+					// 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'));
+
+					this.fullModel = false;
+					this.entityList = false;
+
+					this.serviceInitialized = false;
+
+					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...");
 
-							this._GraphSolver.get(tmpGraphRequestEntity, tmpGraphRequestFilter, tmpCumulation,
-								(pError, pRecords, pValidFilters, pFinalFilters, pJoinedDataSets, pValidIdentities) =>
-								{
-									pResponse.send(
-										{
-											GraphRequestEntity: tmpGraphRequestEntity,
-											GraphRequestFilter: tmpGraphRequestFilter,
+					// 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.`);
 
-											Records: pRecords,
+					// 2. Extract an array of each table in the schema
+					_Fable.log.info(`...getting entity list...`);
+					this.entityList = Object.keys(this.fullModel.Tables);
 
-											ValidFilters: pValidFilters,
-											Finalfilters: pFinalFilters,
+					// 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);
+					}
 
-											JoinedDataSets: pJoinedDataSets,
-											ValidIdentities: pValidIdentities,
+					this.serviceInitialized = true;
 
-											Error: pError
-										});
-									return fNext();		
-								});
-						});
-		
-					return fStageComplete();
-				},
-				(fStageComplete) =>
+					return fCallback();
+				}.bind(this));
+			// Phase VI:  Optionally auto start the orator server.
+			tmpAnticipate.anticipate(
+				function (fCallback)
 				{
-					if (this._Settings.Retold.AutoStartAPIServer)
+					if (this.options.AutoStartOrator)
 					{
-						this.start(fStageComplete);
+						this.fable.log.info(`The Retold Data Service is Auto Starting Orator...`);
+						this.fable.Orator.startWebServer(fCallback);
 					}
 					else
 					{
-						return fStageComplete();
+						return fCallback();
 					}
-				}
-			],
-			(pError)=>
-			{
-				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}`;
-
-		// TODO: Break this out into separate classes
-		this._Orator.webServer.get(`${tmpBackplaneEndpointPrefix}/Model`,
-			(pRequest, pResponse, fNext) =>
-			{
-				pResponse.send(this._MeadowModelGraph);
-				return fNext();
-			});
-	}
-
-	// Lock the service to a specific session (this will bypass auth)
-	lockServiceSession(pSessionData)
-	{
-		if (typeof(pSessionData) != 'object')
-		{
-			this.log.error(`Error locking service session -- invalid object passed in.`, pSessionData);
-			return false;
-		}
-
-		_Fable.log.info(`...Creating Mock User Session and adding it to all requests on Restify/Orator`, pSessionData);
-		var fMockAuthentication = (pRequest, pResponse, fNext) =>
-		{
-			pRequest.UserSession = pSessionData;
-			fNext();
-		};
-		this._Orator.webServer.use(fMockAuthentication);
-	}
-
-	// Load models based on what's in the configuration
-	loadModels()
-	{
-		if (this._Settings.Retold.MeadowModel)
-		{
-			this.loadMeadowModelFile(this._Settings.Retold.MeadowModel);
-		}
-	}
+				}.bind(this));
+			tmpAnticipate.anticipate(this.onAfterInitializeAsync.bind(this));
 
-	loadMeadowModelFile(pModelFilePath)
-	{
-		// TODO: Wrap this in a try/catch/finally
-		this._MeadowModelGraph = require(pModelFilePath);
-		this.loadMeadowModel(this._MeadowModelGraph);
-	}
-
-	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)
-			{
-				this._MeadowEndpoints[tmpDALEntityName].connectRoutes(this._Orator.webServer);
-				this._MeadowEndpoints[tmpDALEntityName].RoutesConnected = true;
-			}
+			// Now anticipate (wait for) initialization to complete.
+			tmpAnticipate.wait(
+				function (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);
+					}
+					return fCallback();
+				}.bind(this));
 		}
 	}
 
-	start(fCallback)
-	{
-		this._Orator.startWebServer(fCallback);
-	}
-
-	get orator()
+	onAfterInitializeAsync(fCallback)
 	{
-		return this._Orator;
+		this.onAfterInitialize();
+		return fCallback();
 	}
-
-	get fable()
-	{
-		return this._Fable;
-	}
-
-	get settings()
+	onAfterInitialize()
 	{
-		return this._Fable.settings;
+		this.log.info("Retold Data Service Application has completed an initialization attempt.");
 	}
 }
 

package/test/RetoldDataService_tests.js

@@ -8,9 +8,10 @@
 
 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 +25,29 @@ 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
+							});
+
+						Expect(tmpRetoldDataService).to.be.an('object', 'Retold Data Service should initialize as an object.');
 
-						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();
+						tmpRetoldDataService.initializeAsync(
+							function(pError)
+							{
+								return fDone();
+							});
 					}
 				);
 			}