meadow-endpoints 3.0.5 → 3.0.7

package/{Dockerfile → Dockerfile_LUXURYCode}

@@ -13,6 +13,48 @@ RUN sudo apt install default-mysql-server default-mysql-client -y
 
 RUN echo "Building RETOLD development image..."
 
+RUN echo "...installing vscode extensions..."
+
+# Mocha unit testing in the sidebar
+RUN code-server --install-extension hbenl.vscode-mocha-test-adapter
+RUN code-server --install-extension hbenl.test-adapter-converter
+RUN code-server --install-extension hbenl.vscode-test-explorer
+
+# Magic indentation rainbow
+RUN code-server --install-extension oderwat.indent-rainbow
+RUN code-server --install-extension dbaeumer.vscode-eslint
+
+# Contextual git
+RUN code-server --install-extension eamodio.gitlens
+
+# Other extensions (uncomment them to have them automagic, or run this from a terminal to install in the container):
+
+# SQL Tools
+RUN code-server --install-extension mtxr.sqltools
+RUN code-server --install-extension mtxr.sqltools-driver-mysql
+
+# Microsoft's AI code completion
+# RUN code-server --install-extension  VisualStudioExptTeam.vscodeintellicode
+
+# Live server -- make sure to open up the port on the docker image
+# RUN code-server --install-extension ritwickdey.LiveServer
+
+# Quick link to required modules' documentation
+RUN code-server --install-extension bengreenier.vscode-node-readme
+
+# Switch up fonts
+# RUN code-server --install-extension evan-buss.font-switcher
+
+# Icons
+# RUN code-server --install-extension vscode-icons-team.vscode-icons
+# RUN code-server --install-extension PKief.material-icon-theme
+
+# Hover over CSS colors to see them previewed
+# RUN code-server --install-extension bierner.color-info
+
+# An easy on the eyes color theme
+# RUN code-server --install-extension daylerees.rainglow
+
 RUN echo "...configuring mariadb (mysql) server..."
 RUN sudo sed -i "s|bind-address|#bind-address|g" /etc/mysql/mariadb.conf.d/50-server.cnf
 ADD ./.config/luxury-extras/MySQL/MySQL-Security.sql /home/coder/MySQL-Configure-Security.sql

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "meadow-endpoints",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "description": "Automatic API endpoints for Meadow data.",
   "main": "source/Meadow-Endpoints.js",
   "scripts": {
     "start": "node source/Meadow-Endpoints.js",
     "coverage": "nyc npm run test && nyc report --reporter=lcov",
     "test": "./node_modules/.bin/mocha --exit -u tdd -R spec",
-    "docker-dev-build-image": "docker build ./ -t retold/meadow-endpoints:local",
+    "build": "./node_modules/.bin/gulp build",
+    "docker-dev-build-image": "docker build ./ -f Dockerfile_LUXURYCode -t retold/meadow-endpoints:local",
     "docker-dev-run": "docker run -it -d --name meadow-endpoints-dev -p 127.0.0.1:12343:8080 -p 12305:3306 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/meadow-endpoints\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/meadow-endpoints:local"
   },
   "mocha": {

package/source/Meadow-Endpoints.js

@@ -64,6 +64,7 @@ var MeadowEndpoints = function()
 			Upserts: require('./crud/Meadow-Endpoint-BulkUpsert.js'),
 
 			Delete: require('./crud/Meadow-Endpoint-Delete.js'),
+			Undelete: require('./crud/Meadow-Endpoint-Undelete.js'),
 
 			Count: require('./crud/Meadow-Endpoint-Count.js'),
 			CountBy: require('./crud/Meadow-Endpoint-CountBy.js'),
@@ -184,6 +185,7 @@ var MeadowEndpoints = function()
 			Delete: true,
 			// DEL  [/1.0/SomeEndpoint]
 			// DEL  [/1.0/SomeEndpoint/:IDRecord]
+			// GET  [/1.0/SomeEndpoint/Undelete/:IDRecord]
 
 			Count: true,
 			// GET  [/1.0/SomeEndpoints/Count]
@@ -379,6 +381,7 @@ var MeadowEndpoints = function()
 			{
 				pRestServer.del(`${tmpEndpointPrefix}`, _CommonServices.bodyParser(), _EndpointAuthenticators.Delete, wireState, _Endpoints.Delete);
 				pRestServer.del(`${tmpEndpointPrefix}/:IDRecord`, _EndpointAuthenticators.Delete, wireState, _Endpoints.Delete);
+				pRestServer.get(`${tmpEndpointPrefix}/Undelete/:IDRecord`, _EndpointAuthenticators.Delete, wireState, _Endpoints.Undelete);
 			}
 			if (_EnabledBehaviors.Count)
 			{
@@ -420,6 +423,17 @@ var MeadowEndpoints = function()
 			return fCallback();
 		};
 
+		var _InvokeSetupCallback;
+		var getInvokeSetupCallback = function()
+		{
+			return _InvokeSetupCallback;
+		};
+
+		var setInvokeSetupCallback = function(fCallback)
+		{
+			_InvokeSetupCallback = fCallback;
+		};
+
 		/**
 		* Invoke a meadow endpoint programmatically
 		*
@@ -472,6 +486,10 @@ var MeadowEndpoints = function()
 					//internal invoke mark as authenticated (because this is not called via webservice)
 					pRequest.EndpointAuthenticated = true;
 
+					if (_InvokeSetupCallback && typeof(_InvokeSetupCallback) == 'function')
+					{
+						_InvokeSetupCallback(pRequest, pResponse, typeof(pOptions) === 'object' && pOptions);
+					}
 					return fStageComplete();
 				},
 				function(fStageComplete)
@@ -516,6 +534,8 @@ var MeadowEndpoints = function()
 			// Expose the DAL
 			DAL: _Meadow,
 
+			getInvokeSetupCallback: getInvokeSetupCallback,
+			setInvokeSetupCallback: setInvokeSetupCallback,
 			invokeEndpoint: invokeEndpoint,
 
 			// Factory

package/source/crud/Meadow-Endpoint-Undelete.js

@@ -0,0 +1,161 @@
+/**
+* Meadow Endpoint - Undelete a Record
+*
+* @license MIT
+*
+* @author Steven Velozo <steven@velozo.com>
+* @module Meadow
+*/
+/**
+* Undelete a record using the Meadow DAL object
+*/
+
+var libAsync = require('async');
+
+
+var doAPIUndeleteEndpoint = function(pRequest, pResponse, fNext)
+{
+	// This state is the requirement for the UserRoleIndex value in the UserSession object... processed by default as >=
+	// The default here is that any authenticated user can use this endpoint.
+	pRequest.EndpointAuthorizationRequirement = pRequest.EndpointAuthorizationLevels.Undelete;
+
+	// INJECT: Pre authorization (for instance to change the authorization level)
+
+	if (pRequest.CommonServices.authorizeEndpoint(pRequest, pResponse, fNext) === false)
+	{
+		// If this endpoint fails, it's sent an error automatically.
+		return;
+	}
+
+	// INJECT: Pre endpoint operation
+
+	var tmpIDRecord = 0;
+	if (typeof(pRequest.params.IDRecord) === 'string')
+	{
+		tmpIDRecord = pRequest.params.IDRecord;
+	}
+	else if (typeof(pRequest.body[pRequest.DAL.defaultIdentifier]) === 'number')
+	{
+		tmpIDRecord = pRequest.body[pRequest.DAL.defaultIdentifier];
+	}
+	else if (typeof(pRequest.body[pRequest.DAL.defaultIdentifier]) === 'string')
+	{
+		tmpIDRecord = pRequest.body[pRequest.DAL.defaultIdentifier];
+	}
+	// Although the undelete request does allow multiple undeletes, we require an identifier.
+	// TODO: Decide if we want to keep this pattern similar to Delete, or, if we want to change it to allow bulk undeletes.
+	if (tmpIDRecord < 1)
+	{
+		return pRequest.CommonServices.sendError('Record undelete failure - a valid record ID is required in the passed-in record.', pRequest, pResponse, fNext);
+	}
+
+	var tmpRecordCount = {};
+	var tmpQuery;
+
+	libAsync.waterfall(
+		[
+			function(fStageComplete)
+			{
+				tmpQuery = pRequest.DAL.query;
+
+				// INJECT: Query configuration and population
+				var tmpSchema = pRequest.DAL.schema;
+				var tmpHasDeletedBit = false;
+				for (let i = 0; i < tmpSchema.length; i++)
+				{
+					if (tmpSchema[i].Type == 'Deleted')
+					{
+						// There is a deleted bit on the record!
+						tmpHasDeletedBit = true;
+					}
+				}
+
+				if (!tmpHasDeletedBit)
+				{
+					return fStageComplete("NO_DELETED_BIT");
+				}
+
+
+				return fStageComplete();
+			},
+			function(fStageComplete)
+			{
+				// Now see if the record, with this identifier, for this user, has the deleted bit set to 1
+				tmpQuery.addFilter(pRequest.DAL.defaultIdentifier, tmpIDRecord);
+				tmpQuery.addFilter('Deleted', 1);
+				tmpQuery.setIDUser(pRequest.UserSession.UserID);
+
+				return fStageComplete();
+			},
+			function(fStageComplete)
+			{
+				// Load the record so we can do security checks on it
+				pRequest.DAL.doRead(tmpQuery,
+					function(pError, pQuery, pRecord)
+					{
+						if (!pRecord)
+						{
+							tmpRecordCount = {Count:0};
+							return fStageComplete("NO_UNDELETABLE_RECORD_FOUND");
+						}
+
+						pRequest.Record = pRecord;
+
+						return fStageComplete();
+					});
+			},
+			function(fStageComplete)
+			{
+				pRequest.Authorizers.authorizeRequest('Undelete', pRequest, fStageComplete);
+			},
+			function(fStageComplete)
+			{
+				// INJECT: Once we've check the authorizer and are ready to Undelete, invoke an injected behavior before we execute the actuall delete operation
+				return pRequest.BehaviorModifications.runBehavior('Undelete-PreOperation', pRequest, fStageComplete);
+			},
+			function(fStageComplete)
+			{
+				// INJECT: Record modification before delete
+
+				if (pRequest.MeadowAuthorization)
+				{
+					return fStageComplete(false);
+				}
+
+				// It looks like this record was not authorized.  Send an error.
+				return fStageComplete({Code:405,Message:'UNAUTHORIZED ACCESS IS NOT ALLOWED'});
+			},
+			function(fStageComplete)
+			{
+				// Do the delete
+				pRequest.DAL.doUndelete(tmpQuery,
+					function(pError, pQuery, pCount)
+					{
+						// It returns the number of rows deleted
+						tmpRecordCount = {Count:pCount};
+
+						return fStageComplete(pError);
+					});
+			},
+			function(fStageComplete)
+			{
+				// INJECT: After the delete count is grabbed, let the user alter the response content
+				return pRequest.BehaviorModifications.runBehavior('Undelete-PostOperation', pRequest, fStageComplete);
+			}
+		], function(pError)
+		{
+			if (pError &&
+				pError !== "NO_RECORD_FOUND")
+			{
+				return pRequest.CommonServices.sendCodedError('Error undeleting a record.', pError, pRequest, pResponse, fNext);
+			}
+
+			pRequest.CommonServices.log.info('Undeleted '+tmpRecordCount.Count+' records with ID '+tmpIDRecord+'.', {SessionID:pRequest.UserSession.SessionID, RequestID:pRequest.RequestUUID, RequestURL:pRequest.url, Action:pRequest.DAL.scope+'-Undelete'}, pRequest);
+			pResponse.send(tmpRecordCount);
+
+			return fNext();
+		}
+	);
+};
+
+module.exports = doAPIUndeleteEndpoint;

package/test/MeadowEndpoints_basic_tests.js

@@ -1007,6 +1007,39 @@ suite
 					}
 				);
 				test
+				(
+					'delete: undelete a record after deleting it',
+					function(fDone)
+					{
+						// Delete animal 4
+						var tmpRecord = {IDAnimal:4};
+						libSuperTest('http://localhost:9080/')
+						.del('1.0/FableTest')
+						.send(tmpRecord)
+						.end(
+							function(pError, pResponse)
+							{
+								// Expect response to be the count of deleted records.
+								var tmpResult = JSON.parse(pResponse.text);
+								Expect(tmpResult.Count).to.equal(1);
+
+								// Now undelete the record
+								libSuperTest('http://localhost:9080/')
+								.get('1.0/FableTest/Undelete/4')
+								.end(
+									function(pError, pResponse)
+									{
+										// Expect response to be the count of deleted records.
+										var tmpResult = JSON.parse(pResponse.text);
+										Expect(tmpResult.Count).to.equal(1);
+										return fDone();
+									}
+								);
+							}
+						);
+					}
+				);
+				test
 				(
 					'delete: delete a record with a bad parameter',
 					function(fDone)
@@ -1540,6 +1573,35 @@ suite
 			{
 				var tmpCreatedRecordGUID;
 
+				test
+				(
+					'invoke: setup method is called',
+					function(fDone)
+					{
+						_MockSessionValidUser.UserRoleIndex = 2;
+						let setupCallCount = 0;
+						let passedRequest, passedResponse, passedOriginalRequest;
+						_MeadowEndpoints.setInvokeSetupCallback((req, res, origReq) =>
+						{
+							++setupCallCount;
+							passedRequest = req;
+							passedResponse = res;
+							passedOriginalRequest = origReq;
+						});
+						const originalRequest = {UserSession: _MockSessionValidUser};
+						_MeadowEndpoints.invokeEndpoint('Read', {IDRecord: 2}, originalRequest,
+							function(pError, pResponse)
+							{
+								Expect(setupCallCount).to.equal(1);
+								Expect(passedOriginalRequest).to.equal(originalRequest);
+								Expect(passedRequest).to.be.an('object');
+								Expect(passedResponse).to.be.an('object');
+
+								fDone();
+							}
+						);
+					}
+				);
 				test
 				(
 					'invoke create: create a record',