meadow-endpoints 4.0.23 → 4.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meadow-endpoints",
-  "version": "4.0.23",
+  "version": "4.0.24",
   "description": "Automatic API endpoints for Meadow data.",
   "main": "source/Meadow-Endpoints.js",
   "scripts": {

package/source/Meadow-Endpoints.js

@@ -73,6 +73,9 @@ class MeadowEndpoints
 			Reads: require('./endpoints/read/Meadow-Endpoint-Reads.js'),
 			ReadsBy: require('./endpoints/read/Meadow-Endpoint-ReadsBy.js'),
 
+			// Body-driven read: filter/pagination/mode travel in a JSON POST body
+			Query: require('./endpoints/read/Meadow-Endpoint-Query.js'),
+
 			ReadSelectList: require('./endpoints/read/Meadow-Endpoint-ReadSelectList.js'),
 			ReadLiteList: require('./endpoints/read/Meadow-Endpoint-ReadLiteList.js'),
 			ReadDistinctList: require('./endpoints/read/Meadow-Endpoint-ReadDistinctList.js'),
@@ -183,6 +186,7 @@ class MeadowEndpoints
 		}
 		if (this._EnabledBehaviorSets.Reads)
 		{
+			this.connectRoute(pServiceServer, 'postWithBodyParser', `s/Query`, this._Endpoints.Query, `the internal behavior _Endpoints.Query`);
 			this.connectRoute(pServiceServer, 'get', `s`, this._Endpoints.Reads, `the internal behavior _Endpoints.Reads`);
 			this.connectRoute(pServiceServer, 'get', `s/By/:ByField/:ByValue`, this._Endpoints.ReadsBy, `the internal behavior _Endpoints.ReadsBy`);
 			this.connectRoute(pServiceServer, 'get', `s/By/:ByField/:ByValue/:Begin/:Cap`, this._Endpoints.ReadsBy, `the internal behavior _Endpoints.ReadsBy`);

package/source/endpoints/read/Meadow-Endpoint-Query.js

@@ -0,0 +1,86 @@
+/**
+* Meadow Endpoint - Body-driven Read
+*
+* 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 behavior hooks, 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.
+*/
+const doReads = require('./Meadow-Endpoint-Reads.js');
+const doReadLite = require('./Meadow-Endpoint-ReadLiteList.js');
+const doReadDistinct = require('./Meadow-Endpoint-ReadDistinctList.js');
+const doCount = require('../count/Meadow-Endpoint-Count.js');
+
+// Body keys hydrated onto pRequest.params so the delegated GET handlers see
+// the same inputs they read from the URI.
+const 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 {Record<string, any>} pBody - the parsed request body
+*
+* @return {string} one of 'Count', 'Distinct', 'Lite', 'Reads'
+*/
+const resolveMode = function(pBody)
+{
+	if (pBody.Count)
+	{
+		return 'Count';
+	}
+	if (pBody.Distinct)
+	{
+		return 'Distinct';
+	}
+	if (pBody.Lite)
+	{
+		return 'Lite';
+	}
+	return 'Reads';
+};
+
+const doAPIEndpointQuery = function(pRequest, pResponse, fNext)
+{
+	const tmpBody = (pRequest.body && typeof(pRequest.body) === 'object') ? pRequest.body : {};
+	pRequest.params = (pRequest.params && typeof(pRequest.params) === 'object') ? pRequest.params : {};
+
+	for (let 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.call(this, pRequest, pResponse, fNext);
+		case 'Distinct':
+			return doReadDistinct.call(this, pRequest, pResponse, fNext);
+		case 'Lite':
+			return doReadLite.call(this, pRequest, pResponse, fNext);
+		case 'Reads':
+		default:
+			return doReads.call(this, pRequest, pResponse, fNext);
+	}
+};
+
+module.exports = doAPIEndpointQuery;

package/test/MeadowEndpoints_basic_tests.js

@@ -505,6 +505,103 @@ suite
 					}
 				);
 				test
+				(
+					"query: reads all records via JSON body (default mode)",
+					function (fDone)
+					{
+						_SuperTest
+							.post("1.0/Books/Query")
+							.send({})
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(pError).to.not.exist;
+									let tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult).to.be.an("array");
+									Expect(tmpResult.length).to.be.at.least(5);
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					"query: reads with filter and pagination in the body",
+					function (fDone)
+					{
+						_SuperTest
+							.post("1.0/Books/Query")
+							.send({ Filter: "FBV~Genre~LK~%Science%", Begin: 0, Cap: 1 })
+							.end(
+								(pError, pResponse) =>
+								{
+									let tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult).to.be.an("array");
+									Expect(tmpResult.length).to.equal(1);
+									Expect(tmpResult[0].Genre).to.contain("Science");
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					"query: Lite read via boolean flag",
+					function (fDone)
+					{
+						_SuperTest
+							.post("1.0/Books/Query")
+							.send({ Lite: true, Begin: 0, Cap: 3 })
+							.end(
+								(pError, pResponse) =>
+								{
+									let tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult).to.be.an("array");
+									Expect(tmpResult.length).to.equal(3);
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					"query: Distinct read via boolean flag and Columns",
+					function (fDone)
+					{
+						_SuperTest
+							.post("1.0/Books/Query")
+							.send({ Distinct: true, Columns: "Genre" })
+							.end(
+								(pError, pResponse) =>
+								{
+									let tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult).to.be.an("array");
+									Expect(tmpResult.length).to.be.at.least(1);
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					"query: Count flag takes precedence and honors the filter",
+					function (fDone)
+					{
+						_SuperTest
+							.post("1.0/Books/Query")
+							.send({ Lite: true, Count: true, Filter: "FBV~Genre~LK~%Science%" })
+							.end(
+								(pError, pResponse) =>
+								{
+									let tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult).to.have.property("Count");
+									Expect(tmpResult.Count).to.be.at.least(3);
+									fDone();
+								}
+							);
+					}
+				);
+				test
 				(
 					'reads by: get records filtered by a field value',
 					function (fDone)