meadow-endpoints 4.0.16 → 4.0.18

package/package.json

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

package/source/Meadow-Endpoints.js

@@ -82,6 +82,7 @@ class MeadowEndpoints
 
 			Upsert: require('./endpoints/upsert/Meadow-Endpoint-Upsert.js'),
 			Upserts: require('./endpoints/upsert/Meadow-Endpoint-BulkUpsert.js'),
+			UpsertsDetailed: require('./endpoints/upsert/Meadow-Endpoint-BulkUpsertDetailed.js'),
 
 			Delete: require('./endpoints/delete/Meadow-Endpoint-Delete.js'),
 			Undelete: require('./endpoints/delete/Meadow-Endpoint-Undelete.js'),
@@ -211,6 +212,7 @@ class MeadowEndpoints
 			this.connectRoute(pServiceServer, 'putWithBodyParser', `s`, this._Endpoints.Updates, `the internal behavior _Endpoints.Updates`);
 			this.connectRoute(pServiceServer, 'putWithBodyParser', `/Upsert`, this._Endpoints.Upsert, `the internal behavior _Endpoints.Upsert`);
 			this.connectRoute(pServiceServer, 'putWithBodyParser', `/Upserts`, this._Endpoints.Upserts, `the internal behavior _Endpoints.Upserts`);
+			this.connectRoute(pServiceServer, 'putWithBodyParser', `/Upserts/Detailed`, this._Endpoints.UpsertsDetailed, `the internal behavior _Endpoints.UpsertsDetailed`);
 		}
 		if (this._EnabledBehaviorSets.Delete)
 		{

package/source/endpoints/create/Meadow-Endpoint-BulkCreate.js

@@ -23,6 +23,12 @@ const doAPIEndpointBulkCreate = function(pRequest, pResponse, fNext)
 
 			return fStageComplete();
 		},
+		// Endpoint-level pre-request hook for bulk creates. Mirror of
+		// Create-PreRequest in the singular Create endpoint — fires
+		// after body-array validation and before any per-record
+		// operation. Use cases include bulk idempotency suppression /
+		// dedup across the incoming batch.
+		fBehaviorInjector(`CreateBulk-PreRequest`),
 		fBehaviorInjector(`CreateBulk-PreOperation`),
 		(fStageComplete) =>
 		{

package/source/endpoints/create/Meadow-Endpoint-Create.js

@@ -19,6 +19,14 @@ const doAPIEndpointCreate = function(pRequest, pResponse, fNext)
 
 			return fStageComplete();
 		},
+		// Endpoint-level pre-request hook. Runs after the body-type check
+		// but before any operation work, mirroring ME 2.x's
+		// Create-PreRequest stage. Use cases include idempotency
+		// suppression (e.g. look up by primary GUID and short-circuit
+		// if the row already exists). Handlers can abort the operation
+		// by calling fStageComplete with a truthy error or by fully
+		// writing pResponse and returning a sentinel.
+		fBehaviorInjector(`Create-PreRequest`),
 		(fStageComplete) =>
 		{
 			doCreate.call(this, pRequest.body, pRequest, tmpRequestState, pResponse, fStageComplete);

package/source/endpoints/delete/Meadow-Endpoint-Delete.js

@@ -55,6 +55,12 @@ const doAPIEndpointDelete = function(pRequest, pResponse, fNext)
 							return fStageComplete(this.ErrorHandler.getError('Record not found.', 404));
 						}
 						tmpRequestState.Record = pRecord;
+						// Alias the loaded pre-delete row for symmetry
+						// with Update (see Meadow-Operation-Update.js).
+						// Post-op hooks that compare pre/post values can
+						// reliably read OriginalRecord without having to
+						// know which stage overwrote Record.
+						tmpRequestState.OriginalRecord = pRecord;
 						return fStageComplete();
 					});
 			},

package/source/endpoints/delete/Meadow-Endpoint-Undelete.js

@@ -70,6 +70,11 @@ const doAPIEndpointUndelete = function(pRequest, pResponse, fNext)
 							return fStageComplete(this.ErrorHandler.getError('Record not found.', 404));
 						}
 						tmpRequestState.Record = pRecord;
+						// Alias the loaded pre-undelete row for symmetry
+						// with Update / Delete (see their endpoints). Post-op
+						// hooks that compare pre/post values can reliably
+						// read OriginalRecord.
+						tmpRequestState.OriginalRecord = pRecord;
 						return fStageComplete();
 					});
 			},

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

@@ -70,6 +70,13 @@ const doAPIEndpointReadDistinct = function(pRequest, pResponse, fNext)
 			tmpRequestState.Records = pRecords;
 			return fStageComplete();
 		},
+		// Stage-specific post-op hook. Fires after DAL read but BEFORE
+		// the records are projected to distinct-column shape, so
+		// handlers can run against full rows. Separate from
+		// Reads-PostOperation so registering one doesn't unintentionally
+		// fire on the other. Hash matches the endpoint's action label
+		// (initializeRequestState(..., 'ReadDistinct')).
+		fBehaviorInjector(`ReadDistinct-PostOperation`),
 		(fStageComplete) =>
 		{
 			tmpRequestState.ResultRecords = marshalDistinctList.call(this, tmpRequestState.Records, pRequest, tmpRequestState.DistinctColumns);

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

@@ -60,8 +60,14 @@ const doAPIEndpointReadLite = function(pRequest, pResponse, fNext)
 					pRecords = [];
 				}
 				tmpRequestState.RawRecords = pRecords;
+				// Expose the loaded records under pRequestState.Records
+				// so post-op hooks operate on the same shape regular
+				// Reads uses. Marshalling to lite shape runs AFTER the
+				// hook so hooks see full rows.
+				tmpRequestState.Records = pRecords;
 				return fStageComplete();
 			},
+			fBehaviorInjector(`ReadsLite-PostOperation`),
 			(fStageComplete) =>
 			{
 				tmpRequestState.Records = marshalLiteList.call(this, tmpRequestState.RawRecords, pRequest, (typeof(pRequest.params.ExtraColumns) === 'string') ? pRequest.params.ExtraColumns.split(',') : []);

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

@@ -54,6 +54,12 @@ const doAPIEndpointReadSelectList = function(pRequest, pResponse, fNext)
 
 				return fStageComplete();
 			},
+			// Stage-specific post-op hook. Fires after DAL read but
+			// BEFORE the records are projected to select-list
+			// (Hash/Value) shape, so handlers can run against full
+			// rows. Separate from Reads-PostOperation so registering
+			// one doesn't unintentionally fire on the other.
+			fBehaviorInjector(`ReadSelectList-PostOperation`),
 			(fStageComplete) =>
 			{
 				tmpRequestState.SelectList = [];

package/source/endpoints/update/Meadow-Operation-Update.js

@@ -49,6 +49,14 @@ const doUpdate = function(pRecordToModify, pRequest, pRequestState, pResponse, f
 							return fStageComplete(this.ErrorHandler.getError('Record not Found', 404));
 						}
 						tmpRequestState.Record = pRecord;
+						// Alias the loaded pre-update row under an
+						// unambiguous name. pRequestState.Record gets
+						// overwritten with the POST-update row later in
+						// this waterfall; OriginalRecord preserves the
+						// PRE-update reference for post-op hooks that
+						// need to compare before/after values (change
+						// logs, customer-boundary checks, etc.).
+						tmpRequestState.OriginalRecord = pRecord;
 						return fStageComplete();
 					});
 			}

package/source/endpoints/upsert/Meadow-Endpoint-BulkUpsert.js

@@ -40,11 +40,35 @@ const doAPIEndpointUpserts = function(pRequest, pResponse, fNext)
 			fBehaviorInjector(`UpsertBulk-PostOperation`),
 			(fStageComplete) =>
 			{
+				// Surface per-row error counts to the caller via response
+				// headers BEFORE streaming the success array. Without these,
+				// callers can only see "N records came back" and have no
+				// signal that other records were silently dropped (e.g.
+				// from a NOT NULL constraint or a column-too-long error).
+				// We keep the response body shape stable (bare array of
+				// upserted records) for back-compat — the headers are the
+				// non-breaking surface for the failure count + total.
+				let tmpInputCount = (tmpRequestState.BulkRecords && tmpRequestState.BulkRecords.length) || 0;
+				let tmpErrorCount = (tmpRequestState.ErrorRecords && tmpRequestState.ErrorRecords.length) || 0;
+				let tmpUpsertedCount = (tmpRequestState.UpsertedRecords && tmpRequestState.UpsertedRecords.length) || 0;
+				try
+				{
+					pResponse.header('X-Meadow-Upsert-Total', String(tmpInputCount));
+					pResponse.header('X-Meadow-Upsert-Succeeded', String(tmpUpsertedCount));
+					pResponse.header('X-Meadow-Upsert-Errored', String(tmpErrorCount));
+				}
+				catch (pHdrErr) { /* response.header may not exist on all servers; degrade silently */ }
+
 				return this.doStreamRecordArray(pResponse, marshalLiteList.call(this, tmpRequestState.UpsertedRecords, pRequest), fStageComplete);
 			},
 			(fStageComplete) =>
 			{
-				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Bulk upsert complete -- ${tmpRequestState.UpsertedRecords.length} records processed`);
+				let tmpUpsertedCount = (tmpRequestState.UpsertedRecords && tmpRequestState.UpsertedRecords.length) || 0;
+				let tmpErrorCount = (tmpRequestState.ErrorRecords && tmpRequestState.ErrorRecords.length) || 0;
+				let tmpMessage = (tmpErrorCount > 0)
+					? `Bulk upsert complete -- ${tmpUpsertedCount} records succeeded, ${tmpErrorCount} errored`
+					: `Bulk upsert complete -- ${tmpUpsertedCount} records processed`;
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, tmpMessage);
 				return fStageComplete();
 			}
 		], (pError) =>

package/source/endpoints/upsert/Meadow-Endpoint-BulkUpsertDetailed.js

@@ -0,0 +1,96 @@
+/**
+* Meadow Endpoint - Upsert a set of Records, with detailed envelope response.
+*
+* Same upsert pipeline as Meadow-Endpoint-BulkUpsert.js, but the
+* response body is an envelope:
+*
+*   {
+*     "Counts":          { "Total": N, "Succeeded": K, "Errored": M },
+*     "UpsertedRecords": [ ... lite-marshaled successes ... ],
+*     "ErrorRecords":    [ { "Record": {...}, "Operation": "...", "Error": "..." }, ... ]
+*   }
+*
+* The vanilla `/Upserts` endpoint streams a bare array of successes for
+* back-compat; this `/Upserts/Detailed` variant trades that compatibility
+* for full per-row error visibility. Same X-Meadow-Upsert-* response
+* headers are set on both.
+*/
+const doUpsert = require('./Meadow-Operation-Upsert.js');
+
+const marshalLiteList = require('../read/Meadow-Marshal-LiteList.js');
+
+const doAPIEndpointUpsertsDetailed = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'UpsertBulkDetailed');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	tmpRequestState.CreatedRecords = [];
+	tmpRequestState.UpdatedRecords = [];
+	tmpRequestState.UpsertedRecords = [];
+	tmpRequestState.ErrorRecords = [];
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				if (!Array.isArray(pRequest.body))
+				{
+					return fStageComplete(this.ErrorHandler.getError(`Record bulk upsert (detailed) failure - a valid array of records is required.`, 500));
+				}
+
+				tmpRequestState.BulkRecords = pRequest.body;
+
+				return fStageComplete();
+			},
+			fBehaviorInjector(`UpsertBulk-PreOperation`),
+			(fStageComplete) =>
+			{
+				this.eachLimit(tmpRequestState.BulkRecords, 1,
+					(pRecord, fCallback) =>
+					{
+						doUpsert.call(this, pRecord, pRequest, tmpRequestState, pResponse, fCallback);
+					}, fStageComplete);
+			},
+			fBehaviorInjector(`UpsertBulk-PostOperation`),
+			(fStageComplete) =>
+			{
+				let tmpInputCount = (tmpRequestState.BulkRecords && tmpRequestState.BulkRecords.length) || 0;
+				let tmpErrorCount = (tmpRequestState.ErrorRecords && tmpRequestState.ErrorRecords.length) || 0;
+				let tmpUpsertedCount = (tmpRequestState.UpsertedRecords && tmpRequestState.UpsertedRecords.length) || 0;
+
+				// Mirror the X-Meadow-Upsert-* headers from /Upserts so a
+				// caller can dispatch to either endpoint and read the same
+				// summary surface. The body envelope adds the per-row
+				// detail; the headers stay the structured summary.
+				try
+				{
+					pResponse.header('X-Meadow-Upsert-Total', String(tmpInputCount));
+					pResponse.header('X-Meadow-Upsert-Succeeded', String(tmpUpsertedCount));
+					pResponse.header('X-Meadow-Upsert-Errored', String(tmpErrorCount));
+				}
+				catch (pHdrErr) { /* response.header may not exist on all servers; degrade silently */ }
+
+				let tmpEnvelope = {
+					Counts: { Total: tmpInputCount, Succeeded: tmpUpsertedCount, Errored: tmpErrorCount },
+					UpsertedRecords: marshalLiteList.call(this, tmpRequestState.UpsertedRecords, pRequest),
+					ErrorRecords: tmpRequestState.ErrorRecords || []
+				};
+				pResponse.send(tmpEnvelope);
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				let tmpUpsertedCount = (tmpRequestState.UpsertedRecords && tmpRequestState.UpsertedRecords.length) || 0;
+				let tmpErrorCount = (tmpRequestState.ErrorRecords && tmpRequestState.ErrorRecords.length) || 0;
+				let tmpMessage = (tmpErrorCount > 0)
+					? `Bulk upsert (detailed) complete -- ${tmpUpsertedCount} records succeeded, ${tmpErrorCount} errored`
+					: `Bulk upsert (detailed) complete -- ${tmpUpsertedCount} records processed`;
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, tmpMessage);
+				return fStageComplete();
+			}
+		], (pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		});
+};
+module.exports = doAPIEndpointUpsertsDetailed;

package/source/endpoints/upsert/Meadow-Operation-Upsert.js

@@ -126,6 +126,21 @@ const doUpsert = function(pRecordToUpsert, pRequest, pRequestState, pResponse, f
 			if (pError)
 			{
 				tmpRequestState.Record.Error = pError;
+				// Surface per-row failures back to the bulk caller. The
+				// parent BulkUpsert endpoint reads this array to count
+				// errors and signal partial-success to clients via a
+				// response header. Without this push, individual upsert
+				// failures vanish silently and the bulk response only
+				// reflects what survived.
+				if (tmpRequestState.ParentRequestState && Array.isArray(tmpRequestState.ParentRequestState.ErrorRecords))
+				{
+					let tmpErrorMessage = (pError && (pError.message || pError.Error)) ? (pError.message || pError.Error) : String(pError);
+					tmpRequestState.ParentRequestState.ErrorRecords.push({
+						Record: tmpRequestState.Record,
+						Operation: tmpRequestState.Operation || 'Unknown',
+						Error: tmpErrorMessage
+					});
+				}
 			}
 			return fCallback();
 		});

package/test/MeadowEndpoints_basic_tests.js

@@ -2404,5 +2404,337 @@ suite
 				);
 			}
 		);
+
+		// ======================================================================
+		// v4.0.17 additions: Create-PreRequest, OriginalRecord retention,
+		// Reads-PostOperation on Lite / Select / Distinct list endpoints.
+		// ======================================================================
+		suite
+		(
+			'Create-PreRequest fires before Create-Operation',
+			() =>
+			{
+				test
+				(
+					'setBehavior: Create-PreRequest hook fires before the operation pipeline',
+					function (fDone)
+					{
+						let tmpFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Create-PreRequest',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpFired = true;
+								// At this stage the operation hasn't started — Record
+								// should be undefined, RecordToCreate shouldn't exist yet
+								// either. The HTTP body is the only record source.
+								Expect(pRequestState.Record).to.be.undefined;
+								Expect(pRequest.body.Title).to.equal('PreRequest Test');
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'PreRequest Test' })
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(tmpFired, 'Create-PreRequest did not fire').to.be.true;
+									let tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult.Title).to.equal('PreRequest Test');
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Create-PreRequest'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Create-PreRequest hook can abort the operation',
+					function (fDone)
+					{
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Create-PreRequest',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								let tmpError = new Error('Rejected by pre-request');
+								tmpError.StatusCode = 400;
+								return fCallback(tmpError);
+							});
+
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'Should be rejected' })
+							.end(
+								(pError, pResponse) =>
+								{
+									let tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult).to.have.property('Error');
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Create-PreRequest'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: CreateBulk-PreRequest fires before per-record operations',
+					function (fDone)
+					{
+						let tmpFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('CreateBulk-PreRequest',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpFired = true;
+								Expect(Array.isArray(pRequest.RecordsToBulkCreate)).to.be.true;
+								Expect(pRequest.RecordsToBulkCreate).to.have.lengthOf(2);
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Books')
+							.send([ { Title: 'Bulk A' }, { Title: 'Bulk B' } ])
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(tmpFired, 'CreateBulk-PreRequest did not fire').to.be.true;
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['CreateBulk-PreRequest'];
+									fDone();
+								}
+							);
+					}
+				);
+			}
+		);
+
+		suite
+		(
+			'OriginalRecord retained on pRequestState after Update/Delete/Undelete',
+			() =>
+			{
+				let _OriginalTestID = 0;
+				test
+				(
+					'pre-op: create a seed record for OriginalRecord testing',
+					function (fDone)
+					{
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'Original Title', Genre: 'Original Genre' })
+							.end(
+								(pError, pResponse) =>
+								{
+									let tmpResult = JSON.parse(pResponse.text);
+									_OriginalTestID = tmpResult.IDBook;
+									Expect(_OriginalTestID).to.be.above(0);
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'Update-PostOperation: pRequestState.OriginalRecord holds the pre-update row',
+					function (fDone)
+					{
+						let tmpSeenOriginal = null;
+						let tmpSeenRecord = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Update-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpSeenOriginal = pRequestState.OriginalRecord;
+								tmpSeenRecord = pRequestState.Record;
+								return fCallback();
+							});
+
+						_SuperTest
+							.put('1.0/Book')
+							.send({ IDBook: _OriginalTestID, Title: 'Updated Title', Genre: 'Updated Genre' })
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(tmpSeenOriginal, 'OriginalRecord should be set at post-op').to.not.be.null;
+									Expect(tmpSeenOriginal.Title).to.equal('Original Title');
+									Expect(tmpSeenRecord.Title).to.equal('Updated Title');
+									// The two references must be DIFFERENT objects — the
+									// operation overwrites Record with the post-update row
+									// while OriginalRecord keeps the pre-update reference.
+									Expect(tmpSeenOriginal).to.not.equal(tmpSeenRecord);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Update-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'Delete-PostOperation: pRequestState.OriginalRecord holds the pre-delete row',
+					function (fDone)
+					{
+						let tmpSeenOriginal = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Delete-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpSeenOriginal = pRequestState.OriginalRecord;
+								return fCallback();
+							});
+
+						_SuperTest
+							.delete(`1.0/Book/${_OriginalTestID}`)
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(tmpSeenOriginal, 'OriginalRecord should be set at delete post-op').to.not.be.null;
+									Expect(tmpSeenOriginal.IDBook).to.equal(_OriginalTestID);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Delete-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'Undelete-PostOperation: pRequestState.OriginalRecord holds the pre-undelete row',
+					function (fDone)
+					{
+						let tmpSeenOriginal = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Undelete-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpSeenOriginal = pRequestState.OriginalRecord;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get(`1.0/Book/Undelete/${_OriginalTestID}`)
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(tmpSeenOriginal, 'OriginalRecord should be set at undelete post-op').to.not.be.null;
+									Expect(tmpSeenOriginal.IDBook).to.equal(_OriginalTestID);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Undelete-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+			}
+		);
+
+		suite
+		(
+			'Stage-specific PostOperation hooks on Lite / SelectList / Distinct list endpoints',
+			() =>
+			{
+				test
+				(
+					'ReadsLite-PostOperation fires on /s/Lite and receives loaded records before marshal (ME 2.x hash)',
+					function (fDone)
+					{
+						let tmpFired = false;
+						let tmpSeenRecords = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('ReadsLite-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpFired = true;
+								tmpSeenRecords = pRequestState.Records;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Books/Lite')
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(tmpFired, 'ReadsLite-PostOperation did not fire on lite list').to.be.true;
+									Expect(Array.isArray(tmpSeenRecords)).to.be.true;
+									// Hook runs BEFORE marshalling — records should still
+									// have their full-row shape (Title + Genre + IDBook etc.),
+									// not the lite (Hash/Value) shape the client receives.
+									if (tmpSeenRecords.length > 0)
+									{
+										Expect(tmpSeenRecords[0]).to.have.property('IDBook');
+									}
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['ReadsLite-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'Reads-PostOperation does NOT fire on /s/Lite (stage isolation)',
+					function (fDone)
+					{
+						let tmpFiredReads = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Reads-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpFiredReads = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Books/Lite')
+							.end(
+								() =>
+								{
+									Expect(tmpFiredReads, 'Reads-PostOperation should NOT fire on lite list — consumers register at ReadsLite-PostOperation').to.be.false;
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Reads-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'ReadSelectList-PostOperation fires on /Select before marshal',
+					function (fDone)
+					{
+						let tmpFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('ReadSelectList-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/BookSelect')
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(tmpFired, 'ReadSelectList-PostOperation did not fire on select list').to.be.true;
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['ReadSelectList-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'ReadDistinct-PostOperation fires on /s/Distinct/:Columns before marshal',
+					function (fDone)
+					{
+						let tmpFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('ReadDistinct-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								tmpFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Books/Distinct/Genre')
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(tmpFired, 'ReadDistinct-PostOperation did not fire on distinct list').to.be.true;
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['ReadDistinct-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+			}
+		);
 	}
 );