meadow-endpoints 4.0.16 → 4.0.17

package/package.json

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

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/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();
+								}
+							);
+					}
+				);
+			}
+		);
 	}
 );