meadow-endpoints 3.0.7 → 4.0.3

package/test_support/bookstore-configuration.json

@@ -0,0 +1,28 @@
+{
+	"Product": "MeadowEndpointsTestBookStore",
+	"ProductVersion": "1.0.0",
+
+	"UUID":
+		{
+			"DataCenter": 0,
+			"Worker": 0
+		},
+	"LogStreams":
+		[
+			{
+				"streamtype": "console"
+			}
+		],
+
+	"APIServerPort": 8086,
+
+	"MySQL":
+		{
+			"Server": "127.0.0.1",
+			"Port": 3306,
+			"User": "root",
+			"Password": "123456789",
+			"Database": "bookstore",
+			"ConnectionPoolLimit": 20
+		}
+}

package/test_support/bookstore-import-books-run.js

@@ -0,0 +1 @@
+let tmpRun = require('./bookstore-import-books.js')();

package/test_support/bookstore-import-books.js

@@ -0,0 +1,215 @@
+/*
+    Import Books directly from CSV to SQL.
+
+    An example of how to use the Meadow DALs directly.
+*/
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+
+// Server Settings
+const _Settings = require('./bookstore-configuration.json');
+// Fable is logging and settings
+const libFable = require('fable');
+// Official MySQL Client
+const libMySQL = require('mysql2');
+// Meadow is the DAL
+const libMeadow = require('meadow');
+
+const libAsync = require('async');
+
+let _Fable = libFable.new(_Settings);
+let _Meadow = libMeadow.new(_Fable);
+
+_Fable.log.info("Application is starting up...");
+
+_Fable.log.info("...Creating SQL Connection pools at "+_Fable.settings.MySQL.Server+"...");
+// Setup SQL Connection Pool
+_Fable.MeadowMySQLConnectionPool = libMySQL.createPool
+	(
+		{
+			connectionLimit: _Fable.settings.MySQL.ConnectionPoolLimit,
+			host: _Fable.settings.MySQL.Server,
+			port: _Fable.settings.MySQL.Port,
+			user: _Fable.settings.MySQL.User,
+			password: _Fable.settings.MySQL.Password,
+			database: _Fable.settings.MySQL.Database,
+			namedPlaceholders: true
+		}
+	);
+
+// Create DAL objects
+let _DAL = {};
+const _BookStoreModel = require (__dirname+'/model/json_schema/BookStore-Extended.json');
+const _BookStoreTableList = Object.keys(_BookStoreModel.Tables);
+_Fable.log.info(`...Creating ${_BookStoreTableList.length} DAL entries...`);
+for (let i = 0; i < _BookStoreTableList.length; i++)
+{
+	let tmpDALEntityName = _BookStoreTableList[i];
+	_Fable.log.info(`   -> Creating the ${tmpDALEntityName} DAL...`);
+	_DAL[tmpDALEntityName] = _Meadow.loadFromPackage(__dirname+'/model/meadow_schema/BookStore-MeadowSchema-'+tmpDALEntityName+'.json');
+	_DAL[tmpDALEntityName].setProvider('MySQL');
+	_DAL[tmpDALEntityName].setIDUser(99999);
+}
+
+const libPapa = require('papaparse');
+const libFS = require('fs');
+
+const _BookData = libFS.readFileSync(`${__dirname}/data/books.csv`, 'utf8');
+
+let tmpBookMap = {};
+let tmpAuthorMap = {};
+
+let fImportBooks = (fCallback) =>
+{
+    console.log('Import operation executing...');
+    let tmpCallback = (typeof(fCallback) == 'function') ? fCallback : ()=>{};
+
+    libPapa.parse(_BookData,
+        {
+            delimiter: ",",
+            header: true,
+            complete:
+                (pResults) =>
+                {
+                    libAsync.waterfall([
+                        (fStageComplete) =>
+                        {
+                            // Enumerate and insert each book
+                            libAsync.eachLimit(pResults.data, 10,
+                                (pBookDataRow, fCallback) =>
+                                {
+                                    let tmpRecordToCreate = (
+                                        {
+                                            Title: pBookDataRow.original_title,
+                                            PublicationYear: isNaN(parseInt(pBookDataRow.original_publication_year, 10)) ? 0 : parseInt(pBookDataRow.original_publication_year, 10),
+                                            ISBN: pBookDataRow.isbn,
+                                            Type: 'Paper',
+                                            Genre: 'UNKNOWN',
+                                            Language: pBookDataRow.language_code,
+                                            ImageURL: pBookDataRow.image_url
+                                        });
+                                    let tmpQuery = _DAL.Book.query;
+                                    //tmpQuery.setLogLevel(5);
+                                    tmpQuery.addRecord(tmpRecordToCreate);
+                                    _DAL.Book.doCreate(tmpQuery,
+                                        (pError, pQuery, pQueryRead, pRecord)=>
+                                        {
+                                            // Add it to the book map
+                                            if (!pError)
+                                            {
+                                                tmpBookMap[pBookDataRow.id] = pRecord.IDBook;
+                                                //_Fable.log.info('Imported book ID '+pRecord.IDBook+' title ['+pRecord.Title+']');
+                                            }
+                                            fCallback(pError);
+                                        });
+
+                                },
+                                (pError)=>
+                                {
+                                    _Fable.log.info('...Book Import operation complete!');
+                                    fStageComplete()
+                                });
+                        },
+                        (fStageComplete) =>
+                        {
+                            // Enumerate and insert each author
+                            libAsync.eachLimit(pResults.data, 10,
+                                (pBookDataRow, fCallback) =>
+                                {
+                                    if (!pBookDataRow.hasOwnProperty('authors'))
+                                        return fCallback();
+
+                                    let tmpAuthorsToCreate = pBookDataRow.authors.split(',');
+
+                                    libAsync.eachLimit(tmpAuthorsToCreate, 1,
+                                        (pAuthor, fAuthorInsertCallback)=>
+                                        {
+                                            if (tmpAuthorMap.hasOwnProperty(pAuthor))
+                                            {
+                                                return fAuthorInsertCallback();
+                                            }
+                                            else
+                                            {
+                                                tmpAuthorMap[pAuthor] = false;
+                                            }
+                                            let tmpRecordToCreate = (
+                                                {
+                                                    Name: pAuthor
+                                                });
+                                            let tmpQuery = _DAL.Author.query.addRecord(tmpRecordToCreate);
+                                            _DAL.Author.doCreate(tmpQuery,
+                                                (pError, pQuery, pQueryRead, pRecord)=>
+                                                {
+                                                    if (!pError)
+                                                    {
+                                                        tmpAuthorMap[pRecord.Name] = pRecord.IDAuthor;
+                                                        //_Fable.log.info('Imported Author ID '+pRecord.IDAuthor+' named ['+pRecord.Name+']');
+                                                    }
+                                                    return fAuthorInsertCallback(pError);
+                                                });
+                                        },
+                                        (pError)=>
+                                        {
+                                            return fCallback(pError);
+                                        });
+                                },
+                                (pError)=>
+                                {
+                                    _Fable.log.info('...Author Import operation complete!');
+                                    fStageComplete();
+                                });
+                        },
+                        (fStageComplete) =>
+                        {
+                            // Create Book->Author joins
+                            libAsync.eachLimit(pResults.data, 10,
+                                (pBookDataRow, fCallback) =>
+                                {
+                                    if (!pBookDataRow.hasOwnProperty('authors'))
+                                        return fCallback();
+
+                                    let tmpAuthorJoinsToCreate = pBookDataRow.authors.split(',');
+
+                                    libAsync.eachLimit(tmpAuthorJoinsToCreate, 1,
+                                        (pAuthor, fAuthorJoinInsertCallback)=>
+                                        {
+                                            let tmpRecordToCreate = (
+                                                {
+                                                    IDBook: tmpBookMap[pBookDataRow.id],
+                                                    IDAuthor: tmpAuthorMap[pAuthor]
+                                                });
+                                            let tmpQuery = _DAL.BookAuthorJoin.query.addRecord(tmpRecordToCreate);
+                                            _DAL.BookAuthorJoin.doCreate(tmpQuery,
+                                                (pError, pQuery, pQueryRead, pRecord)=>
+                                                {
+                                                    if (!pError)
+                                                    {
+                                                        //_Fable.log.info(`Joined author ${pAuthor} ID ${pRecord.IDAuthor} to book ID ${pRecord.IDBook}`);
+                                                    }
+                                                    return fAuthorJoinInsertCallback(pError);
+                                                });
+                                        },
+                                        (pError)=>
+                                        {
+                                            return fCallback(pError);
+                                        });
+                                },
+                                (pError)=>
+                                {
+                                    _Fable.log.info('...Join Import operation complete!');
+                                    return fStageComplete(pError);
+                                });
+                        }
+                    ],
+                    (pError)=>
+                    {
+                        _Fable.log.info('Full import operation has completed!')
+                        tmpCallback(pError);
+                    });
+                }
+        });
+}
+
+module.exports = fImportBooks;

package/test_support/bookstore-serve-meadow-endpoint-apis-IPC.js

@@ -0,0 +1,138 @@
+/*
+	An example of Meadow Endpoints, Fable and Orator
+*/
+const libWhyMe = require('why-is-node-running');
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+
+// Server Settings
+const _Settings = require('./bookstore-configuration.json');
+// Fable is logging and settings
+const libFable = require('fable');
+// Orator is the web server
+const libOrator = require('orator');
+// Official MySQL Client
+const libMySQL = require('mysql2');
+// Meadow is the DAL
+const libMeadow = require('meadow');
+// Meadow-endpoints maps the DAL to restify endpoints automagically
+const libMeadowEndpoints = require('../source/Meadow-Endpoints.js');
+
+let _Fable = new libFable(_Settings);
+let _Orator = new libOrator(_Fable);
+
+let fStartServiceServer = (fInitializeCallback) =>
+{
+	_Orator.initializeServiceServer((pError) =>
+		{
+			let _Meadow = libMeadow.new(_Fable);
+
+			_Fable.log.info("Application is starting up...");
+
+			_Fable.log.info("...Creating SQL Connection pools at "+_Fable.settings.MySQL.Server+"...");
+			_Fable.MeadowMySQLConnectionPool = libMySQL.createPool
+				(
+					{
+						connectionLimit: _Fable.settings.MySQL.ConnectionPoolLimit,
+						host: _Fable.settings.MySQL.Server,
+						port: _Fable.settings.MySQL.Port,
+						user: _Fable.settings.MySQL.User,
+						password: _Fable.settings.MySQL.Password,
+						database: _Fable.settings.MySQL.Database,
+						namedPlaceholders: true
+					}
+				);
+
+			// Create DAL objects for each table in the schema
+			let _DAL = {};
+			let _MeadowEndpoints = {};
+
+			// 1. Load full compiled schema of the model from stricture
+			_Fable.log.info(`...Loading stricture schemas...`);
+			const _BookStoreModel = require (__dirname+'/model/json_schema/BookStore-Extended.json');
+
+			// 2. Extract an array of each table in the schema
+			const _BookStoreTableList = Object.keys(_BookStoreModel.Tables);
+
+			// 3. Enumerate each entry in the compiled model and load a DAL for that table
+			_Fable.log.info(`...Creating ${_BookStoreTableList.length} DAL entries...`);
+			for (let i = 0; i < _BookStoreTableList.length; i++)
+			{
+				let tmpDALEntityName = _BookStoreTableList[i];
+				_Fable.log.info(`   -> Creating the ${tmpDALEntityName} DAL...`);
+				// 4. Create the DAL for each entry (e.g. it would be at _DAL.Book or _DAL.Author)
+				_DAL[tmpDALEntityName] = _Meadow.loadFromPackage(__dirname+'/model/meadow_schema/BookStore-MeadowSchema-'+tmpDALEntityName+'.json');
+				// 5. Tell this DAL object to use MySQL
+				_DAL[tmpDALEntityName].setProvider('MySQL');
+				// 6. Set the User ID to 10 just for fun
+				_DAL[tmpDALEntityName].setIDUser(1);
+				// 7. Create a Meadow Endpoints class for this DAL
+				_MeadowEndpoints[tmpDALEntityName] = libMeadowEndpoints.new(_DAL[tmpDALEntityName]);
+				// 8. Expose the meadow endpoints on Orator
+				_MeadowEndpoints[tmpDALEntityName].connectRoutes(_Orator.webServer);
+			}
+
+			// 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.controller.BehaviorInjection.setBehavior('Read-PostOperation',
+				(pRequest, pRequestState, fComplete) =>
+				{
+					// Get the join records
+					_DAL.BookAuthorJoin.doReads(_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
+							{
+								_DAL.Author.doReads(_DAL.Author.query.addFilter('IDAuthor', tmpAuthorList, 'IN'),
+									(pReadsError, pReadsQuery, pAuthors)=>
+									{
+										pRequestState.Record.Authors = pAuthors;
+										return fComplete();
+									});
+							}
+						});
+				});
+
+			// Static site mapping
+			_Orator.log.info("...Mapping static route for web site...");
+
+			//_Orator.addStaticRoute(__dirname+'/../web/');
+
+			// Start the web server (ctrl+c to end it)
+			_Orator.startWebServer(
+				(pError) =>
+				{
+					// Now do a GET!
+					let tmpURI = `/1.0/Book/1`;
+					_Orator.invoke('GET', tmpURI, null, 
+						(pError, pResponseData) =>
+						{
+							_Orator.log.info(`Response to [${tmpURI}] came back from IPC resulting in [${pResponseData}]!`);
+							_Fable.MeadowMySQLConnectionPool.end();
+							libWhyMe();
+							return true;
+						});
+					fInitializeCallback(pError);
+				}
+			);
+		});
+	return _Orator;
+}
+
+module.exports = fStartServiceServer;

package/test_support/bookstore-serve-meadow-endpoint-apis-run.js

@@ -0,0 +1,6 @@
+const libServer = require('./bookstore-serve-meadow-endpoint-apis.js'); 
+let _Orator = libServer(
+	()=>
+	{
+		console.log('API service is started!');
+	});

package/test_support/bookstore-serve-meadow-endpoint-apis.js

@@ -0,0 +1,129 @@
+/*
+	An example of Meadow Endpoints, Fable and Orator
+*/
+
+/**
+* @license MIT
+* @author <steven@velozo.com>
+*/
+
+// Server Settings
+const _Settings = require('./bookstore-configuration.json');
+// Fable is logging and settings
+const libFable = require('fable');
+// Orator is the web server
+const libOrator = require('orator');
+const libOratorServiceServerRestify = require('orator-serviceserver-restify');
+// Official MySQL Client
+const libMySQL = require('mysql2');
+// Meadow is the DAL
+const libMeadow = require('meadow');
+// Meadow-endpoints maps the DAL to restify endpoints automagically
+const libMeadowEndpoints = require('../source/Meadow-Endpoints.js');
+
+let _Fable = new libFable(_Settings);
+let _Orator = new libOrator(_Fable, libOratorServiceServerRestify);
+
+let fStartServiceServer = (fInitializeCallback) =>
+{
+	_Orator.initializeServiceServer(() =>
+		{
+			let _Meadow = libMeadow.new(_Fable);
+
+			_Fable.log.info("Application is starting up...");
+
+			_Fable.log.info("...Creating SQL Connection pools at "+_Fable.settings.MySQL.Server+"...");
+			_Fable.MeadowMySQLConnectionPool = libMySQL.createPool
+				(
+					{
+						connectionLimit: _Fable.settings.MySQL.ConnectionPoolLimit,
+						host: _Fable.settings.MySQL.Server,
+						port: _Fable.settings.MySQL.Port,
+						user: _Fable.settings.MySQL.User,
+						password: _Fable.settings.MySQL.Password,
+						database: _Fable.settings.MySQL.Database,
+						namedPlaceholders: true
+					}
+				);
+
+			// Create DAL objects for each table in the schema
+			let _DAL = {};
+			let _MeadowEndpoints = {};
+
+			// 1. Load full compiled schema of the model from stricture
+			_Fable.log.info(`...Loading stricture schemas...`);
+			const _BookStoreModel = require (__dirname+'/model/json_schema/BookStore-Extended.json');
+
+			// 2. Extract an array of each table in the schema
+			const _BookStoreTableList = Object.keys(_BookStoreModel.Tables);
+
+			// 3. Enumerate each entry in the compiled model and load a DAL for that table
+			_Fable.log.info(`...Creating ${_BookStoreTableList.length} DAL entries...`);
+			for (let i = 0; i < _BookStoreTableList.length; i++)
+			{
+				let tmpDALEntityName = _BookStoreTableList[i];
+				_Fable.log.info(`   -> Creating the ${tmpDALEntityName} DAL...`);
+				// 4. Create the DAL for each entry (e.g. it would be at _DAL.Book or _DAL.Author)
+				_DAL[tmpDALEntityName] = _Meadow.loadFromPackage(__dirname+'/model/meadow_schema/BookStore-MeadowSchema-'+tmpDALEntityName+'.json');
+				// 5. Tell this DAL object to use MySQL
+				_DAL[tmpDALEntityName].setProvider('MySQL');
+				// 6. Set the User ID to 10 just for fun
+				_DAL[tmpDALEntityName].setIDUser(1);
+				// 7. Create a Meadow Endpoints class for this DAL
+				_MeadowEndpoints[tmpDALEntityName] = libMeadowEndpoints.new(_DAL[tmpDALEntityName]);
+				// 8. Expose the meadow endpoints on Orator
+				_MeadowEndpoints[tmpDALEntityName].connectRoutes(_Orator.webServer);
+			}
+
+			// 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.controller.BehaviorInjection.setBehavior('Read-PostOperation',
+				(pRequest, pRequestState, fComplete) =>
+				{
+					// Get the join records
+					_DAL.BookAuthorJoin.doReads(_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
+							{
+								_DAL.Author.doReads(_DAL.Author.query.addFilter('IDAuthor', tmpAuthorList, 'IN'),
+									(pReadsError, pReadsQuery, pAuthors)=>
+									{
+										pRequestState.Record.Authors = pAuthors;
+										return fComplete();
+									});
+							}
+						});
+				});
+
+			// Static site mapping
+			_Orator.log.info("...Mapping static route for web site...");
+
+			//_Orator.addStaticRoute(__dirname+'/../web/');
+
+			// Start the web server (ctrl+c to end it)
+			_Orator.startWebServer(
+				(pError) =>
+				{
+					fInitializeCallback(pError);
+				}
+			);
+		});
+	return _Orator;
+}
+
+module.exports = fStartServiceServer;