fable 3.0.37 → 3.0.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.0.37",
+  "version": "3.0.39",
   "description": "An entity behavior management and API bundling library.",
   "main": "source/Fable.js",
   "scripts": {
@@ -10,7 +10,8 @@
     "build": "./node_modules/.bin/gulp build",
     "build-compatible": "GULP_CUSTOM_BUILD_TARGET=compatible ./node_modules/.bin/gulp build",
     "docker-dev-build-image": "docker build ./ -f Dockerfile_LUXURYCode -t retold/fable:local",
-    "docker-dev-run": "docker run -it -d --name retold-fable-dev -p 30001:8080 -p 8086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/fable:local"
+    "docker-dev-run": "docker run -it -d --name retold-fable-dev -p 30001:8080 -p 8086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/fable:local",
+    "docker-dev-shell": "docker exec -it retold-fable-dev /bin/bash"
   },
   "mocha": {
     "diff": true,
@@ -31,7 +32,8 @@
     ]
   },
   "browser": {
-    "./source/service/Fable-Service-EnvironmentData.js": "./source/service/Fable-Service-EnvironmentData-Web.js"
+    "./source/service/Fable-Service-EnvironmentData.js": "./source/service/Fable-Service-EnvironmentData-Web.js",
+    "./source/service/Fable-Service-FilePersistence.js": "./source/service/Fable-Service-FilePersistence-Web.js"
   },
   "repository": {
     "type": "git",
@@ -71,6 +73,7 @@
     "fable-serviceproviderbase": "^3.0.3",
     "fable-settings": "^3.0.5",
     "fable-uuid": "^3.0.5",
+    "manyfest": "^1.0.24",
     "precedent": "^1.0.10",
     "simple-get": "^4.0.1"
   }

package/retold-harness/bookstore-serve-meadow-endpoint-apis.js

@@ -3,6 +3,7 @@
 */
 
 /**
+* @license MIT
 * @author <steven@velozo.com>
 */
 
@@ -74,16 +75,13 @@ let fStartServiceServer = (fInitializeCallback) =>
 				_MeadowEndpoints[tmpDALEntityName].connectRoutes(_Orator.webServer);
 			}
 
-			let tmpNames = Object.keys(_MeadowEndpoints.Book);
-			console.log(JSON.stringify(tmpNames));
-
 			// 100. Add a post processing hook to the Book DAL on single reads
 			/*
 				This post processing step will look for all book author joins then 
 				load all appropriate authors and stuff them in the book record before 
 				returning it.
 			*/
-			_MeadowEndpoints.Book.behaviorModifications.setBehavior('Read-PostOperation',
+			_MeadowEndpoints.Book.controller.BehaviorInjection.setBehavior('Read-PostOperation',
 				(pRequest, pRequestState, fComplete) =>
 				{
 					// Get the join records

package/retold-harness/package.json

@@ -11,10 +11,10 @@
   "license": "MIT",
   "dependencies": {
     "async": "^3.2.4",
-    "fable": "^3.0.35",
+    "fable": "^3.0.37",
     "meadow": "^2.0.4",
-    "meadow-endpoints": "^3.0.7",
-    "mysql2": "^3.3.0",
+    "meadow-endpoints": "^4.0.2",
+    "mysql2": "^3.3.1",
     "orator": "^3.0.11",
     "orator-serviceserver-restify": "^1.0.4",
     "papaparse": "^5.4.1"

package/source/Fable.js

@@ -9,15 +9,6 @@ const libFableLog = require('fable-log');
 
 const libFableServiceManager = require('./Fable-ServiceManager.js');
 
-// Default Services
-const libFableServiceEnvironmentData = require('./services/Fable-Service-EnvironmentData.js');
-const libFableServiceDataFormat = require('./services/Fable-Service-DataFormat.js');
-const libFableServiceMetaTemplate = require('./services/Fable-Service-MetaTemplate.js');
-const libFableServiceOperation = require('./services/Fable-Service-Operation.js');
-const libFableServiceRestClient = require('./services/Fable-Service-RestClient.js');
-const libFableServiceTemplate = require('./services/Fable-Service-Template.js');
-const libFableServiceUtility = require('./services/Fable-Service-Utility.js');
-
 class Fable
 {
 	constructor(pSettings)
@@ -51,14 +42,20 @@ class Fable
 		this.serviceManager.connectPreinitServiceProviderInstance(this._coreServices.SettingsManager);
 
 		// Initialize and instantiate the default baked-in Data Arithmatic service
-		this.serviceManager.addAndInstantiateServiceType('EnvironmentData', libFableServiceEnvironmentData);
-		this.serviceManager.addServiceType('Template', libFableServiceTemplate);
-		this.serviceManager.addServiceType('MetaTemplate', libFableServiceMetaTemplate);
-		this.serviceManager.addAndInstantiateServiceType('DataFormat', libFableServiceDataFormat);
-		this.serviceManager.addAndInstantiateServiceType('Utility', libFableServiceUtility);
-		this.serviceManager.addServiceType('Operation', libFableServiceOperation);
-		this.serviceManager.addServiceType('RestClient', libFableServiceRestClient);
+		this.serviceManager.addAndInstantiateServiceType('EnvironmentData', require('./services/Fable-Service-EnvironmentData.js'));
+		this.serviceManager.addServiceType('Template', require('./services/Fable-Service-Template.js'));
+		this.serviceManager.addServiceType('MetaTemplate', require('./services/Fable-Service-MetaTemplate.js'));
+		this.serviceManager.addAndInstantiateServiceType('DataFormat', require('./services/Fable-Service-DataFormat.js'));
+		this.serviceManager.addAndInstantiateServiceType('Utility', require('./services/Fable-Service-Utility.js'));
+		this.serviceManager.addServiceType('Operation', require('./services/Fable-Service-Operation.js'));
+		this.serviceManager.addServiceType('RestClient', require('./services/Fable-Service-RestClient.js'));
+		this.serviceManager.addServiceType('CSVParser', require('./services/Fable-Service-CSVParser.js'));
+		this.serviceManager.addServiceType('Manifest', require('manyfest'));
+	}
 
+	get isFable()
+	{
+		return true;
 	}
 
 	get settings()
@@ -94,7 +91,7 @@ class Fable
 	get fable()
 	{
 		return this;
-	}
+	};
 }
 
 // This is for backwards compatibility

package/source/services/Fable-Service-CSVParser.js

@@ -0,0 +1,199 @@
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+/**
+* Parsing CSVs.  Why?  Because it's a thing that needs to be done.
+*
+* 1. And the other node CSV parsers had issues with the really messy files we had.
+* 
+*
+* 2. None of the CSV parsers dealt with and multi-line quoted string columns
+*    which are apparently a-ok according to the official spec.
+* Plus a lot of them are asynchronous because apparently that's the best way to
+* do anything; unfortunately some files have a sequence issue with that.
+*
+* @class CSVParser
+*/
+class CSVParser extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'CSVParser';
+
+        this.Header = [];
+        this.HeaderFieldNames = [];
+
+        this.Delimiter = ',';
+        this.QuoteCharacter = '"';
+
+        this.CleanCharacters = ['\r'];
+
+        this.HeaderLineIndex = 0;
+        this.HasHeader = true;
+        this.HasSetHeader = false;
+        this.EmitHeader = false;
+
+        this.EmitJSON = true;
+
+        this.EscapedQuoteString = '"';
+
+        // Current Line Parsing State
+        this.CurrentLine = '';
+        this.CurrentRecord = [];
+
+        this.InQuote = false;
+        this.InEscapedQuote = false;
+
+        this.LinesParsed = 0;
+        this.RowsEmitted = 0;
+    }
+
+    marshalRowToJSON(pRowArray)
+    {
+        if (!Array.isArray(pRowArray))
+        {
+            return false;
+        }
+
+        for (let i = this.HeaderFieldNames.length; i < pRowArray.length; i++)
+        {
+            this.HeaderFieldNames[i] = `${i}`;
+        }
+
+        let tmpObject = {};
+
+        for (let i = 0; i < pRowArray.length; i++)
+        {
+            tmpObject[this.HeaderFieldNames[i]] = pRowArray[i];
+        }
+
+        return tmpObject;
+    }
+
+    // Set the header data, for use in marshalling to JSON.
+    setHeader (pHeaderArray)
+    {
+        this.Header = pHeaderArray;
+
+        for (let i = 0; i < this.Header.length; i++)
+        {
+            if (typeof(this.Header[i]) == 'undefined')
+            {
+                this.HeaderFieldNames[i] = `${i}`;
+            }
+            else
+            {
+                this.HeaderFieldNames[i] = this.Header[i].toString();
+            }
+        }
+    }
+
+    resetRowState()
+    {
+        this.CurrentRecord = [];
+    }
+
+    pushLine()
+    {
+        for (let i = 0; i < this.CleanCharacters.length; i++)
+        {
+            this.CurrentLine = this.CurrentLine.replace(this.CleanCharacters[i],'');
+        }
+        this.CurrentRecord.push(this.CurrentLine);
+        this.CurrentLine = '';
+    }
+
+    emitRow(pFormatAsJSON)
+    {
+        let tmpFormatAsJSON = (typeof(pFormatAsJSON) == 'undefined') ? this.EmitJSON : pFormatAsJSON;
+
+        this.RowsEmitted++;
+        let tmpCompletedRecord = this.CurrentRecord;
+        this.CurrentRecord = [];
+
+        if (tmpFormatAsJSON)
+        {
+            return this.marshalRowToJSON(tmpCompletedRecord);
+        }
+        else
+        {
+            return tmpCompletedRecord;
+        }
+    }
+
+    parseCSVLine (pLineString)
+    {
+        this.LinesParsed++;
+
+        for (let i = 0; i < pLineString.length; i++)
+        {
+            if ((!this.InQuote) && (pLineString[i] == this.Delimiter))
+            {
+                this.pushLine();
+            }
+            else if (pLineString[i] == this.QuoteCharacter)
+            {
+                // If we are in the second part of an escaped quote, ignore it.
+                if (this.InEscapedQuote)
+                {
+                    this.InEscapedQuote = false;
+                }
+                // If we aren't in a quote, enter quote
+                else if (!this.InQuote)
+                {
+                    this.InQuote = true;
+                }
+                // We are in a quote, so peek forward to see if this is an "escaped" quote pair
+                else if ((i < pLineString.length) && (pLineString[i+1] == this.QuoteCharacter))
+                {
+                    this.CurrentLine += this.EscapedQuoteString;
+                    this.InEscapedQuote = true;
+                }
+                // We are in a quote, this isn't an "escaped" quote pair, so go out of quote mode
+                else
+                {
+                    this.InQuote = false;
+                }
+            }
+            else
+            {
+                this.CurrentLine += pLineString[i];
+            }
+        }
+
+        // See if we are in a multiline quoted entry -- if not, emit the row.
+        if (!this.InQuote)
+        {
+            // Push the last remaining column from the buffer to the current line.
+            this.pushLine();
+
+            // Check to see if there is a header -- and if so, if this is the header row
+            if (this.HasHeader && !this.HasSetHeader && (this.RowsEmitted == this.HeaderLineIndex))
+            {
+                this.HasSetHeader = true;
+                // Override the format as json bit
+                this.setHeader(this.emitRow(false));
+
+                // No matter what, formatting this as JSON is silly and we don't want to go there anyway.
+                if (this.EmitHeader)
+                {
+                    return this.Header;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                return this.emitRow();
+            }
+        }
+        else
+        {
+            return false;
+        }
+    };
+}
+
+module.exports = CSVParser;

package/source/services/Fable-Service-DataFormat.js

@@ -1,6 +1,3 @@
-/**
-*/
-
 const libFableServiceProviderBase = require('fable-serviceproviderbase');
 /**
 * Data Formatting and Translation Functions

package/source/services/Fable-Service-FilePersistence-Web.js

@@ -0,0 +1,36 @@
+const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+
+class FableServiceFilePersistence extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'FilePersistence';
+
+        if (!this.options.hasOwnProperty('Mode'))
+        {
+            this.options.Mode = parseInt('0777', 8) & ~process.umask();
+        }
+	}
+
+    existsSync(pPath)
+    {
+        //return libFS.existsSync(pPath);
+        return false;
+    }
+
+    exists(pPath, fCallback)
+    {
+        let tmpFileExists = this.existsSync(pPath);;
+
+        return fCallback(null, tmpFileExists);
+    }
+
+    makeFolderRecursive (pParameters, fCallback)
+    {
+        return fCallback();
+    }
+}
+
+module.exports = FableServiceFilePersistence;

package/source/services/Fable-Service-FilePersistence.js

@@ -0,0 +1,127 @@
+const libFableServiceBase = require('../Fable-ServiceManager.js').ServiceProviderBase;
+
+const libFS = require('fs');
+const libPath = require('path');
+
+
+class FableServiceFilePersistence extends libFableServiceBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'FilePersistence';
+
+        if (!this.options.hasOwnProperty('Mode'))
+        {
+            this.options.Mode = parseInt('0777', 8) & ~process.umask();
+        }
+	}
+
+    existsSync(pPath)
+    {
+        return libFS.existsSync(pPath);
+    }
+
+    exists(pPath, fCallback)
+    {
+        let tmpFileExists = this.existsSync(pPath);;
+
+        return fCallback(null, tmpFileExists);
+    }
+
+    makeFolderRecursive (pParameters, fCallback)
+    {
+        let tmpParameters = pParameters;
+
+        if (typeof(pParameters) == 'string')
+        {
+            tmpParameters = { Path: pParameters };
+        }
+        else if (typeof(pParameters) !== 'object')
+        {
+            fCallback(new Error('Parameters object or string not properly passed to recursive folder create.'));
+            return false;
+        }
+
+        if ((typeof(tmpParameters.Path) !== 'string'))
+        {
+            fCallback(new Error('Parameters object needs a path to run the folder create operation.'));
+            return false;
+        }
+
+        if (!tmpParameters.hasOwnProperty('Mode'))
+        {
+            tmpParameters.Mode = this.options.Mode;
+        }
+
+        // Check if we are just starting .. if so, build the initial state for our recursive function
+        if (typeof(tmpParameters.CurrentPathIndex) === 'undefined')
+        {
+            // Build the tools to start recursing
+            tmpParameters.ActualPath = libPath.normalize(tmpParameters.Path);
+            tmpParameters.ActualPathParts = tmpParameters.ActualPath.split(libPath.sep);
+            tmpParameters.CurrentPathIndex = 0;
+            tmpParameters.CurrentPath = '';
+        }
+        else
+        {
+            // This is not our first run, so we will continue the recursion.
+            // Build the new base path
+            if (tmpParameters.CurrentPath == libPath.sep)
+            {
+                tmpParameters.CurrentPath = tmpParameters.CurrentPath + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex];
+            }
+            else
+            {
+                tmpParameters.CurrentPath = tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex];
+            }
+
+            // Increment the path index
+            tmpParameters.CurrentPathIndex++;
+        }
+
+        // Check if the path is fully complete
+        if (tmpParameters.CurrentPathIndex >= tmpParameters.ActualPathParts.length)
+        {
+            fCallback(null);
+            return true;
+        }
+
+        // Check if the path exists
+        libFS.open(tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex], 'r',
+            function(pError, pFileDescriptor)
+            {
+                if (pFileDescriptor)
+                {
+                    libFS.closeSync(pFileDescriptor);
+                }
+
+                if (pError && pError.code=='ENOENT')
+                {
+                    /* Path doesn't exist, create it */
+                    libFS.mkdir(tmpParameters.CurrentPath + libPath.sep + tmpParameters.ActualPathParts[tmpParameters.CurrentPathIndex], tmpParameters.Mode,
+                        (pCreateError) =>
+                        {
+                            if (!pCreateError)
+                            {
+                                // We have now created our folder and there was no error -- continue.
+                                return this.makeFolderRecursive(tmpParameters, fCallback);
+                            }
+                            else
+                            {
+                                fCallback(pCreateError);
+                                return false;
+                            }
+                        });
+                }
+                else
+                {
+                    return this.makeFolderRecursive(tmpParameters, fCallback);
+                }
+            }
+        );
+    }
+}
+
+module.exports = FableServiceFilePersistence;

package/source/services/Fable-Service-Utility.js

@@ -85,8 +85,9 @@ class FableServiceUtility extends libFableServiceBase
 	//                and: 1986-06-11T09:34:46.012Z+0200
 	// ... and converts them into javascript timestamps, following the directions of the timezone stuff.
 	//
-	// This is not meant to replace the more complex libraries.
-	// This *is* meant to be a simple, small, and fast way to convert ISO strings to dates in engines with limited JS capabilities.
+	// This is not meant to replace the more complex libraries such as moment or luxon.
+	// This *is* meant to be a simple, small, and fast way to convert ISO strings to dates in engines
+	// with ultra limited JS capabilities where those don't work.
 	isoStringToDate (pISOString)
 	{
 

package/test/CSVParser_tests.js

@@ -0,0 +1,66 @@
+/**
+* Unit tests for Fable
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+const libFS = require('fs');
+const libReadline = require('readline');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'CSV Parser',
+	function()
+	{
+		suite
+		(
+			'Parse CSV',
+			function()
+			{
+				test
+				(
+					'Pull CSV Data',
+					function(fDone)
+					{
+						let testFable = new libFable();
+						let tmpCSVParser = testFable.serviceManager.instantiateServiceProvider('CSVParser', {Name: 'Big Complex Integration Operation'}, 'CSV Parser-123');
+						let tmpRecords = [];
+
+						const tmpReadline = libReadline.createInterface(
+						{
+							input: libFS.createReadStream(`${__dirname}/data/books.csv`),
+							crlfDelay: Infinity
+						});
+
+						tmpReadline.on('line', 
+							(pLine) =>
+							{
+								let tmpRecord = tmpCSVParser.parseCSVLine(pLine);
+								if (tmpRecord)
+								{
+									tmpRecords.push(tmpRecord);
+								}
+							});
+
+						tmpReadline.on('close',
+							() =>
+							{
+								console.log(`Readline closed... testing import!`);
+								Expect(tmpRecords.length).to.equal(10000);
+								Expect(tmpRecords[0].authors).to.equal('Suzanne Collins');
+								return fDone();
+							});
+
+					}
+				);
+			}
+		);
+	}
+);

package/test/FilePersistence_tests.js

@@ -0,0 +1,37 @@
+/**
+* Unit tests for Fable
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var libFable = require('../source/Fable.js');
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+suite
+(
+	'File Persistence',
+	function()
+	{
+		suite
+		(
+			'Work with Files',
+			function()
+			{
+				test
+				(
+					'Recursively Create a Folder',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						return fDone();
+					}
+				);
+			}
+		);
+	}
+);