meadow-endpoints 4.0.15 → 4.0.17

package/test/MeadowEndpoints_basic_tests.js

@@ -1408,6 +1408,743 @@ suite
 							);
 					}
 				);
+
+				// ==================================================================
+				// New hooks added 2026-04-18 to restore ME2 parity
+				// (Update-Pre, Update-Query) and to extend ME4's bulk-level hooks
+				// to Update/Upsert (UpdateBulk-*, UpsertBulk-*).
+				// ==================================================================
+
+				test
+				(
+					'setBehavior: Update-PreOperation hook can mutate RecordToModify before DAL update',
+					function (fDone)
+					{
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Update-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								// Hook sees the incoming payload on RecordToModify,
+								// existing loaded row on Record. Mutations to
+								// RecordToModify flow through to the DAL update.
+								Expect(pRequestState.RecordToModify).to.be.an('object');
+								pRequestState.RecordToModify.Genre = 'MutatedByPreOp';
+								return fCallback();
+							});
+
+						_SuperTest
+							.put('1.0/Book')
+							.send({ IDBook: 4, Title: 'Snow Crash (v2)' })
+							.end(
+								(pError, pResponse) =>
+								{
+									let tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult.Genre).to.equal('MutatedByPreOp');
+									Expect(tmpResult.Title).to.equal('Snow Crash (v2)');
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Update-PreOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Update-PreOperation hook can reject an update',
+					function (fDone)
+					{
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Update-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								if (!pRequestState.RecordToModify.Title)
+								{
+									const tmpError = new Error('Title is required');
+									tmpError.StatusCode = 400;
+									return fCallback(tmpError);
+								}
+								return fCallback();
+							});
+
+						_SuperTest
+							.put('1.0/Book')
+							.send({ IDBook: 3 })
+							.end(
+								(pError, pResponse) =>
+								{
+									const tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult).to.have.property('Error');
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Update-PreOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Update-QueryConfiguration hook fires after Query.addRecord',
+					function (fDone)
+					{
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Update-QueryConfiguration',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								// Query should exist and have had the record added;
+								// hook can scope the update further.
+								Expect(pRequestState.Query).to.exist;
+								pRequestState.Query.addFilter('Deleted', 0);
+								return fCallback();
+							});
+
+						_SuperTest
+							.put('1.0/Book')
+							.send({ IDBook: 2, Title: 'Dune (updated)' })
+							.end(
+								(pError, pResponse) =>
+								{
+									const tmpResult = JSON.parse(pResponse.text);
+									Expect(tmpResult.Title).to.equal('Dune (updated)');
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Update-QueryConfiguration'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: UpdateBulk-PreOperation fires once before the batch',
+					function (fDone)
+					{
+						let _CallCount = 0;
+						let _SawBulkRecords = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('UpdateBulk-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_CallCount++;
+								_SawBulkRecords = Array.isArray(pRequestState.BulkRecords);
+								return fCallback();
+							});
+
+						_SuperTest
+							.put('1.0/Books')
+							.send([
+								{ IDBook: 1, Title: 'Angels & Demons (batch)' },
+								{ IDBook: 2, Title: 'Dune (batch)' },
+							])
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(_CallCount).to.equal(1);
+									Expect(_SawBulkRecords).to.equal(true);
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['UpdateBulk-PreOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: UpdateBulk-PostOperation fires once after the batch',
+					function (fDone)
+					{
+						let _CallCount = 0;
+						let _SawUpdatedRecords = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('UpdateBulk-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_CallCount++;
+								_SawUpdatedRecords = Array.isArray(pRequestState.UpdatedRecords) && pRequestState.UpdatedRecords.length > 0;
+								return fCallback();
+							});
+
+						_SuperTest
+							.put('1.0/Books')
+							.send([
+								{ IDBook: 3, Title: 'Neuromancer (batch post)' },
+							])
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(_CallCount).to.equal(1);
+									Expect(_SawUpdatedRecords).to.equal(true);
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['UpdateBulk-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: UpsertBulk-PreOperation fires once before the batch',
+					function (fDone)
+					{
+						let _CallCount = 0;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('UpsertBulk-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_CallCount++;
+								Expect(Array.isArray(pRequestState.BulkRecords)).to.equal(true);
+								return fCallback();
+							});
+
+						_SuperTest
+							.put('1.0/Book/Upserts')
+							.send([
+								{ Title: 'Bulk Upsert New 1' },
+								{ Title: 'Bulk Upsert New 2' },
+							])
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(_CallCount).to.equal(1);
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['UpsertBulk-PreOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: UpsertBulk-PostOperation fires once after the batch',
+					function (fDone)
+					{
+						let _CallCount = 0;
+						let _SawUpserted = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('UpsertBulk-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_CallCount++;
+								_SawUpserted = Array.isArray(pRequestState.UpsertedRecords) && pRequestState.UpsertedRecords.length > 0;
+								return fCallback();
+							});
+
+						_SuperTest
+							.put('1.0/Book/Upserts')
+							.send([
+								{ Title: 'Bulk Upsert Post 1' },
+							])
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(_CallCount).to.equal(1);
+									Expect(_SawUpserted).to.equal(true);
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['UpsertBulk-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+
+				// ==================================================================
+				// Coverage backfill for hooks that were present but previously
+				// untested. Each test registers a handler, fires the endpoint,
+				// and asserts the hook observed the expected state. These also
+				// act as stage-semantics documentation for the hook surface.
+				// ==================================================================
+
+				test
+				(
+					'setBehavior: Create-QueryConfiguration fires after Query.addRecord',
+					function (fDone)
+					{
+						let _Seen = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Create-QueryConfiguration',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_Seen = {
+									hasQuery: !!pRequestState.Query,
+									hasRecordToCreate: !!pRequestState.RecordToCreate,
+								};
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'Query-Config hook target' })
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(_Seen).to.deep.equal({ hasQuery: true, hasRecordToCreate: true });
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Create-QueryConfiguration'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Create-PostOperation sees the freshly-inserted Record',
+					function (fDone)
+					{
+						let _SeenIDBook = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Create-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_SeenIDBook = pRequestState.Record && pRequestState.Record.IDBook;
+								pRequestState.Record.PostOpTag = 'was-here';
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'Post-op hook target' })
+							.end(
+								(pError, pResponse) =>
+								{
+									const tmpResult = JSON.parse(pResponse.text);
+									Expect(_SeenIDBook).to.be.above(0);
+									Expect(tmpResult.PostOpTag).to.equal('was-here');
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Create-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: CreateBulk-PreOperation fires once with RecordsToBulkCreate',
+					function (fDone)
+					{
+						let _CallCount = 0;
+						let _SawRecords = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('CreateBulk-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_CallCount++;
+								_SawRecords = Array.isArray(pRequest.RecordsToBulkCreate);
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Books')
+							.send([
+								{ Title: 'Bulk Create 1' },
+								{ Title: 'Bulk Create 2' },
+							])
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(_CallCount).to.equal(1);
+									Expect(_SawRecords).to.equal(true);
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['CreateBulk-PreOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: CreateBulk-PostOperation fires once with CreatedRecords',
+					function (fDone)
+					{
+						let _SawCreated = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('CreateBulk-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_SawCreated = Array.isArray(pRequestState.CreatedRecords) && pRequestState.CreatedRecords.length;
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Books')
+							.send([
+								{ Title: 'Bulk Create Post 1' },
+							])
+							.end(
+								(pError, pResponse) =>
+								{
+									Expect(_SawCreated).to.equal(1);
+
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['CreateBulk-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Delete-QueryConfiguration can scope the delete query',
+					function (fDone)
+					{
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Delete-QueryConfiguration',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								Expect(pRequestState.Query).to.exist;
+								return fCallback();
+							});
+
+						// Use a record we don't care about the state of; create one inline.
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'Delete-Query target' })
+							.end(
+								(pPostErr, pPostRes) =>
+								{
+									const tmpID = JSON.parse(pPostRes.text).IDBook;
+									_SuperTest
+										.delete(`1.0/Book/${tmpID}`)
+										.end(
+											(pDelErr, pDelRes) =>
+											{
+												delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Delete-QueryConfiguration'];
+												fDone();
+											}
+										);
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Delete-PostOperation fires after soft-delete',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Delete-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'Delete-Post target' })
+							.end(
+								(pPostErr, pPostRes) =>
+								{
+									const tmpID = JSON.parse(pPostRes.text).IDBook;
+									_SuperTest
+										.delete(`1.0/Book/${tmpID}`)
+										.end(
+											() =>
+											{
+												Expect(_HookFired).to.equal(true);
+												delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Delete-PostOperation'];
+												fDone();
+											}
+										);
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Read-QueryConfiguration runs after filter is applied',
+					function (fDone)
+					{
+						let _SeenCriteria = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Read-QueryConfiguration',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_SeenCriteria = pRequestState.RecordSearchCriteria;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Book/1')
+							.end(
+								() =>
+								{
+									Expect(_SeenCriteria).to.be.a('string').and.satisfy((pS) => pS.includes('IDBook'));
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Read-QueryConfiguration'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Reads-PostOperation fires after list load',
+					function (fDone)
+					{
+						let _SawRecords = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Reads-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_SawRecords = Array.isArray(pRequestState.Records) && pRequestState.Records.length > 0;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Books/0/10')
+							.end(
+								() =>
+								{
+									Expect(_SawRecords).to.equal(true);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Reads-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: ReadMax-QueryConfiguration fires with column name',
+					function (fDone)
+					{
+						let _SeenColumn = null;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('ReadMax-QueryConfiguration',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_SeenColumn = pRequestState.ColumnName;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Book/Max/PublicationYear')
+							.end(
+								() =>
+								{
+									Expect(_SeenColumn).to.equal('PublicationYear');
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['ReadMax-QueryConfiguration'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: ReadMax-PostOperation fires after max lookup',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('ReadMax-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Book/Max/PublicationYear')
+							.end(
+								() =>
+								{
+									Expect(_HookFired).to.equal(true);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['ReadMax-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: CountBy-QueryConfiguration can modify count-by query',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('CountBy-QueryConfiguration',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								Expect(pRequestState.Query).to.exist;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Books/Count/By/Genre/Thriller')
+							.end(
+								() =>
+								{
+									Expect(_HookFired).to.equal(true);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['CountBy-QueryConfiguration'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Undelete-PreOperation fires before undelete',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Undelete-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								return fCallback();
+							});
+
+						// Create, delete, then undelete to hit the hook.
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'Undelete-Pre target' })
+							.end(
+								(pPostErr, pPostRes) =>
+								{
+									const tmpID = JSON.parse(pPostRes.text).IDBook;
+									_SuperTest
+										.delete(`1.0/Book/${tmpID}`)
+										.end(
+											() =>
+											{
+												_SuperTest
+													.get(`1.0/Book/Undelete/${tmpID}`)
+													.end(
+														() =>
+														{
+															Expect(_HookFired).to.equal(true);
+															delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Undelete-PreOperation'];
+															fDone();
+														}
+													);
+											}
+										);
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Undelete-PostOperation fires after undelete',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Undelete-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Book')
+							.send({ Title: 'Undelete-Post target' })
+							.end(
+								(pPostErr, pPostRes) =>
+								{
+									const tmpID = JSON.parse(pPostRes.text).IDBook;
+									_SuperTest
+										.delete(`1.0/Book/${tmpID}`)
+										.end(
+											() =>
+											{
+												_SuperTest
+													.get(`1.0/Book/Undelete/${tmpID}`)
+													.end(
+														() =>
+														{
+															Expect(_HookFired).to.equal(true);
+															delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Undelete-PostOperation'];
+															fDone();
+														}
+													);
+											}
+										);
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Schema-PreOperation fires before schema render',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Schema-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Book/Schema')
+							.end(
+								() =>
+								{
+									Expect(_HookFired).to.equal(true);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Schema-PreOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Validate-PreOperation fires before validate',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Validate-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Book/Schema/Validate')
+							.send({ Title: 'Validate target' })
+							.end(
+								() =>
+								{
+									Expect(_HookFired).to.equal(true);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Validate-PreOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: Validate-PostOperation fires after validate',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('Validate-PostOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.post('1.0/Book/Schema/Validate')
+							.send({ Title: 'Validate target 2' })
+							.end(
+								() =>
+								{
+									Expect(_HookFired).to.equal(true);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['Validate-PostOperation'];
+									fDone();
+								}
+							);
+					}
+				);
+				test
+				(
+					'setBehavior: New-PreOperation fires before empty record render',
+					function (fDone)
+					{
+						let _HookFired = false;
+						_MeadowEndpoints.controller.BehaviorInjection.setBehavior('New-PreOperation',
+							(pRequest, pRequestState, fCallback) =>
+							{
+								_HookFired = true;
+								return fCallback();
+							});
+
+						_SuperTest
+							.get('1.0/Book/Schema/New')
+							.end(
+								() =>
+								{
+									Expect(_HookFired).to.equal(true);
+									delete _MeadowEndpoints.controller.BehaviorInjection._BehaviorFunctions['New-PreOperation'];
+									fDone();
+								}
+							);
+					}
+				);
 			}
 		);
 
@@ -1667,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();
+								}
+							);
+					}
+				);
+			}
+		);
 	}
 );