meadow-endpoints 2.0.22 → 2.0.24

package/.babelrc

@@ -0,0 +1,6 @@
+{
+    "presets": [
+        "@babel/preset-env"
+    ],
+    "sourceMaps": "both"
+}

package/.browserslistrc

@@ -0,0 +1 @@
+since 2022

package/.browserslistrc-BACKUP

@@ -0,0 +1 @@
+since 2022

package/.gulpfile-quackage-config.json

@@ -0,0 +1,8 @@
+{
+    "EntrypointInputSourceFile": "/home/alex/dev/retold/modules/meadow/meadow-endpoints/source/Meadow-Endpoints.js",
+    "LibraryObjectName": "MeadowEndpoints",
+    "LibraryOutputFolder": "/home/alex/dev/retold/modules/meadow/meadow-endpoints/dist/",
+    "LibraryUniminifiedFileName": "meadow-endpoints.js",
+    "LibraryMinifiedFileName": "meadow-endpoints.min.js",
+    "BrowserifyIgnore": []
+}

package/.gulpfile-quackage.js

@@ -0,0 +1,2 @@
+require('/home/alex/dev/retold/modules/meadow/meadow-endpoints/node_modules/quackage/gulp/Quackage-Gulpfile.js');
+require('/home/alex/dev/retold/modules/meadow/meadow-endpoints/node_modules/quackage/gulp/Quackage-Gulpfile.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meadow-endpoints",
-  "version": "2.0.22",
+  "version": "2.0.24",
   "description": "Automatic API endpoints for Meadow data.",
   "main": "source/Meadow-Endpoints.js",
   "scripts": {
@@ -44,7 +44,7 @@
   "homepage": "https://github.com/stevenvelozo/meadow-endpoints",
   "devDependencies": {
     "chai": "4.1.2",
-    "chance": "^1.1.8",
+    "chance": "^1.1.13",
     "fable": "^2.0.1",
     "mocha": "9.2.2",
     "mysql2": "1.6.1",
@@ -55,7 +55,7 @@
     "async": "2.6.1",
     "JSONStream": "^1.3.5",
     "meadow": "~1.0.32",
-    "meadow-filter": "^1.0.5",
+    "meadow-filter": "^1.0.10",
     "orator": "~2.0.2",
     "underscore": "1.9.1"
   }

package/source/Meadow-Endpoints.js

@@ -54,6 +54,9 @@ var MeadowEndpoints = function()
 			Reads: require('./crud/Meadow-Endpoint-Reads.js'),
 			ReadsBy: require('./crud/Meadow-Endpoint-ReadsBy.js'),
 
+			// Body-driven read: filter/pagination/mode travel in a JSON POST body
+			Query: require('./crud/Meadow-Endpoint-Query.js'),
+
 			ReadSelectList: require('./crud/Meadow-Endpoint-ReadSelectList.js'),
 			ReadLiteList: require('./crud/Meadow-Endpoint-ReadLiteList.js'),
 			ReadDistinctList: require('./crud/Meadow-Endpoint-ReadDistinctList.js'),
@@ -343,6 +346,7 @@ var MeadowEndpoints = function()
 			}
 			if (_EnabledBehaviors.Reads)
 			{
+				pRestServer.post(`${tmpEndpointPrefix}s/Query`, _CommonServices.bodyParser(), _EndpointAuthenticators.Reads, wireState, _Endpoints.Query);
 				pRestServer.get(`${tmpEndpointPrefix}s`, _EndpointAuthenticators.Reads, wireState, _Endpoints.Reads);
 				pRestServer.get(`${tmpEndpointPrefix}s/By/:ByField/:ByValue`, _EndpointAuthenticators.Reads, wireState, _Endpoints.ReadsBy);
 				pRestServer.get(`${tmpEndpointPrefix}s/By/:ByField/:ByValue/:Begin/:Cap`, _EndpointAuthenticators.Reads, wireState, _Endpoints.ReadsBy);

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

@@ -0,0 +1,93 @@
+/**
+* Meadow Endpoint - Body-driven Read
+*
+* @license MIT
+*
+* @author Steven Velozo <steven@velozo.com>
+* @module Meadow
+*/
+
+/**
+* A single POST endpoint that carries the filter, pagination and read-mode
+* selection in a JSON body instead of the URI. This sidesteps URI length
+* limits hit by complex filters and large IN-lists, while reusing the exact
+* GET read handlers (and therefore their authorizers, marshalling and response
+* shapes) by mapping the body onto pRequest.params and delegating.
+*
+* Body envelope:
+*   {
+*     "Filter": "FBV~Genre~EQ~Books~...",   // meadow-filter string
+*     "Begin": 0,
+*     "Cap": 250,
+*     "ExtraColumns": "ColumnA,ColumnB",    // Lite read
+*     "Columns": "ColumnA,ColumnB",         // Distinct read
+*     "Lite": true, "Distinct": true, "Count": true
+*   }
+*
+* The read mode is selected by the flags, resolved by precedence:
+* Count > Distinct > Lite > Reads (the default). This lets a caller compose a
+* read query (filter, pagination, Lite/Distinct shaping) and flip Count on to
+* get the count of that same query.
+*/
+var doReads = require('./Meadow-Endpoint-Reads.js');
+var doReadLite = require('./Meadow-Endpoint-ReadLiteList.js');
+var doReadDistinct = require('./Meadow-Endpoint-ReadDistinctList.js');
+var doCount = require('./Meadow-Endpoint-Count.js');
+
+// Body keys hydrated onto pRequest.params so the delegated GET handlers see
+// the same inputs they read from the URI.
+var PARAM_KEYS = [ 'Filter', 'Begin', 'Cap', 'ExtraColumns', 'Columns' ];
+
+/**
+* Resolve the read mode from the request body flags, by precedence:
+* Count > Distinct > Lite > Reads (the default).
+*
+* @param {Object} pBody - the parsed request body
+*
+* @return {String} one of 'Count', 'Distinct', 'Lite', 'Reads'
+*/
+var resolveMode = function(pBody)
+{
+	if (pBody.Count)
+	{
+		return 'Count';
+	}
+	if (pBody.Distinct)
+	{
+		return 'Distinct';
+	}
+	if (pBody.Lite)
+	{
+		return 'Lite';
+	}
+	return 'Reads';
+};
+
+var doAPIQueryEndpoint = function(pRequest, pResponse, fNext)
+{
+	var tmpBody = (pRequest.body && typeof(pRequest.body) === 'object') ? pRequest.body : {};
+	pRequest.params = (pRequest.params && typeof(pRequest.params) === 'object') ? pRequest.params : {};
+
+	for (var i = 0; i < PARAM_KEYS.length; i++)
+	{
+		if (typeof(tmpBody[PARAM_KEYS[i]]) !== 'undefined')
+		{
+			pRequest.params[PARAM_KEYS[i]] = tmpBody[PARAM_KEYS[i]];
+		}
+	}
+
+	switch (resolveMode(tmpBody))
+	{
+		case 'Count':
+			return doCount(pRequest, pResponse, fNext);
+		case 'Distinct':
+			return doReadDistinct(pRequest, pResponse, fNext);
+		case 'Lite':
+			return doReadLite(pRequest, pResponse, fNext);
+		case 'Reads':
+		default:
+			return doReads(pRequest, pResponse, fNext);
+	}
+};
+
+module.exports = doAPIQueryEndpoint;

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

@@ -111,6 +111,11 @@ var doAPIReadLiteEndpoint = function(pRequest, pResponse, fNext)
 				// It looks like this record was not authorized.  Send an error.
 				return fStageComplete({Code:405,Message:'UNAUTHORIZED ACCESS IS NOT ALLOWED'});
 			},
+			// 2.7: INJECT: Post-operation behavior (e.g. field cleansing)
+			function (fStageComplete)
+			{
+				pRequest.BehaviorModifications.runBehavior('ReadsLite-PostOperation', pRequest, fStageComplete);
+			},
 			// 3. Marshalling of records into the hash list, using underscore templates.
 			function (fStageComplete)
 			{

package/test/MeadowEndpoints_basic_tests.js

@@ -588,6 +588,102 @@ suite
 					}
 				);
 				test
+				(
+					'query: reads all records via JSON body (default mode)',
+					function(fDone)
+					{
+						libSuperTest('http://localhost:9080/')
+						.post('1.0/FableTests/Query')
+						.send({})
+						.end(
+							function (pError, pResponse)
+							{
+								var tmpResults = JSON.parse(pResponse.text);
+								Expect(tmpResults).to.be.an('array');
+								Expect(tmpResults.length).to.equal(6);
+								fDone();
+							}
+						);
+					}
+				);
+				test
+				(
+					'query: reads with filter in the body',
+					function(fDone)
+					{
+						libSuperTest('http://localhost:9080/')
+						.post('1.0/FableTests/Query')
+						.send({ Filter: 'FBV~Type~EQ~Dog' })
+						.end(
+							function (pError, pResponse)
+							{
+								var tmpResults = JSON.parse(pResponse.text);
+								Expect(tmpResults).to.be.an('array');
+								Expect(tmpResults.length).to.equal(2);
+								Expect(tmpResults[0].Type).to.equal('Dog');
+								fDone();
+							}
+						);
+					}
+				);
+				test
+				(
+					'query: Lite read via boolean flag with pagination',
+					function(fDone)
+					{
+						libSuperTest('http://localhost:9080/')
+						.post('1.0/FableTests/Query')
+						.send({ Lite: true, Begin: 0, Cap: 3 })
+						.end(
+							function (pError, pResponse)
+							{
+								var tmpResults = JSON.parse(pResponse.text);
+								Expect(tmpResults).to.be.an('array');
+								Expect(tmpResults.length).to.equal(3);
+								fDone();
+							}
+						);
+					}
+				);
+				test
+				(
+					'query: Distinct read via boolean flag and Columns',
+					function(fDone)
+					{
+						libSuperTest('http://localhost:9080/')
+						.post('1.0/FableTests/Query')
+						.send({ Distinct: true, Columns: 'Type' })
+						.end(
+							function (pError, pResponse)
+							{
+								var tmpResults = JSON.parse(pResponse.text);
+								Expect(tmpResults).to.be.an('array');
+								Expect(tmpResults.length).to.be.at.least(1);
+								fDone();
+							}
+						);
+					}
+				);
+				test
+				(
+					'query: Count flag takes precedence and honors the filter',
+					function(fDone)
+					{
+						libSuperTest('http://localhost:9080/')
+						.post('1.0/FableTests/Query')
+						.send({ Lite: true, Count: true, Filter: 'FBV~Type~EQ~Dog' })
+						.end(
+							function (pError, pResponse)
+							{
+								var tmpResults = JSON.parse(pResponse.text);
+								Expect(tmpResults).to.have.property('Count');
+								Expect(tmpResults.Count).to.equal(2);
+								fDone();
+							}
+						);
+					}
+				);
+				test
 				(
 					'readsLiteExtended: get all records',
 					function(fDone)
@@ -608,6 +704,91 @@ suite
 					}
 				);
 				test
+				(
+					'readsLite: ReadsLite-PostOperation behavior fires and can modify records',
+					function(fDone)
+					{
+						_MeadowEndpoints.behaviorModifications.setBehavior('ReadsLite-PostOperation',
+							function(pRequest, fComplete)
+							{
+								// Simulate field cleansing by removing Type from all records
+								pRequest.Records.forEach(function(pRecord)
+								{
+									delete pRecord.Type;
+								});
+								fComplete(false);
+							});
+						libSuperTest('http://localhost:9080/')
+						.get('1.0/FableTests/LiteExtended/Type,Name')
+						.end(
+							function (pError, pResponse)
+							{
+								var tmpResults = JSON.parse(pResponse.text);
+								Expect(tmpResults.length).to.equal(6);
+								// Type was requested via LiteExtended but removed by PostOperation behavior
+								Expect(tmpResults[0]).to.not.have.property('Type');
+								Expect(tmpResults[4]).to.not.have.property('Type');
+								// Name was not removed and should still be present
+								Expect(tmpResults[4].Name).to.equal('Gertrude');
+								// Clean up
+								_MeadowEndpoints.behaviorModifications.setBehavior('ReadsLite-PostOperation', null);
+								fDone();
+							}
+						);
+					}
+				);
+				test
+				(
+					'readsLite: ReadsLite-PostOperation behavior fires for standard Lite endpoint',
+					function(fDone)
+					{
+						var tmpBehaviorFired = false;
+						_MeadowEndpoints.behaviorModifications.setBehavior('ReadsLite-PostOperation',
+							function(pRequest, fComplete)
+							{
+								tmpBehaviorFired = true;
+								fComplete(false);
+							});
+						libSuperTest('http://localhost:9080/')
+						.get('1.0/FableTests/Lite')
+						.end(
+							function (pError, pResponse)
+							{
+								var tmpResults = JSON.parse(pResponse.text);
+								Expect(tmpResults.length).to.equal(6);
+								Expect(tmpBehaviorFired).to.equal(true);
+								// Clean up
+								_MeadowEndpoints.behaviorModifications.setBehavior('ReadsLite-PostOperation', null);
+								fDone();
+							}
+						);
+					}
+				);
+				test
+				(
+					'readsLite: ReadsLite-PostOperation error halts response',
+					function(fDone)
+					{
+						_MeadowEndpoints.behaviorModifications.setBehavior('ReadsLite-PostOperation',
+							function(pRequest, fComplete)
+							{
+								fComplete({Code:403,Message:'SENSITIVE FIELD ACCESS DENIED'});
+							});
+						libSuperTest('http://localhost:9080/')
+						.get('1.0/FableTests/LiteExtended/Type,Name')
+						.end(
+							function (pError, pResponse)
+							{
+								var tmpResult = JSON.parse(pResponse.text);
+								Expect(tmpResult).to.have.property('Error');
+								// Clean up
+								_MeadowEndpoints.behaviorModifications.setBehavior('ReadsLite-PostOperation', null);
+								fDone();
+							}
+						);
+					}
+				);
+				test
 				(
 					'readsby: get all records by Type',
 					function(fDone)