meadow-endpoints 4.0.15 → 4.0.17

package/source/controller/utility/Meadow-Endpoints-Filter-Parser.js

@@ -11,24 +11,24 @@ const { parse } = require('meadow-filter');
 
 class MeadowEndpointsFilterParser
 {
-    /**
-     * @param {import('../Meadow-Endpoints-Controller-Base.js')} pController - The controller instance to which this parser belongs.
-     */
-    constructor(pController)
+	/**
+	 * @param {import('../Meadow-Endpoints-Controller-Base.js')} pController - The controller instance to which this parser belongs.
+	 */
+	constructor(pController)
 	{
-        this._Controller = pController;
-    }
+		this._Controller = pController;
+	}
 
-    /**
-     * @param {string} pFilterString - The filter string to parse.
-     * @param {any} pQuery - The foxhound query object to populate.
-     *
-     * @return {boolean} - True if the filter was parsed successfully, false otherwise.
-     */
-    parseFilter(pFilterString, pQuery)
-    {
-        return parse(pFilterString, pQuery);
-    }
+	/**
+	 * @param {string} pFilterString - The filter string to parse.
+	 * @param {any} pQuery - The foxhound query object to populate.
+	 *
+	 * @return {boolean} - True if the filter was parsed successfully, false otherwise.
+	 */
+	parseFilter(pFilterString, pQuery)
+	{
+		return parse(pFilterString, pQuery);
+	}
 }
 
 module.exports = MeadowEndpointsFilterParser;

package/source/controller/utility/Meadow-Endpoints-Session-Marshaler.js

@@ -1,52 +1,52 @@
 class MeadowEndpointsSessionMarshaler
 {
-    /**
-     * @param {import('../Meadow-Endpoints-Controller-Base.js')} pController
-     */
-    constructor(pController)
+	/**
+	 * @param {import('../Meadow-Endpoints-Controller-Base.js')} pController
+	 */
+	constructor(pController)
 	{
-        this._Controller = pController;
-    }
+		this._Controller = pController;
+	}
 
-    getSessionData(pRequest)
-    {
-        let tmpSession = Object.assign({}, this._Controller.settings.MeadowEndpointsDefaultSessionObject);
-        let tmpHeaderSessionString;
+	getSessionData(pRequest)
+	{
+		let tmpSession = Object.assign({}, this._Controller.settings.MeadowEndpointsDefaultSessionObject);
+		let tmpHeaderSessionString;
 
-        switch (this._Controller.settings.MeadowEndpointsSessionDataSource || 'Request')
-        {
-            default:
-                this._Controller.log.warn(`Unknown session source configured: ${this._Controller.settings.MeadowEndpointsSessionDataSource} - defaulting to Request for backward compatibility`);
-            case 'Request':
-                // noop - already set by orator-session
-                tmpSession = this._Controller.extend(tmpSession, pRequest.UserSession);
-                break;
-            case 'None':
-                break;
-            case 'Header':
-                try
-                {
-                    tmpHeaderSessionString = pRequest.headers['x-trusted-session'];
-                    if (!tmpHeaderSessionString)
-                    {
-                        break;
-                    }
-                    const tmpHeaderSession = JSON.parse(tmpHeaderSessionString);
-                    tmpSession = this._Controller.extend(tmpSession, tmpHeaderSession);
-                }
-                catch (pError)
-                {
-                    this._Controller.log.error(`Meadow Endpoints attempted to process a Header Session String with value [${tmpHeaderSessionString}] and failed -- likely culprit is bad JSON.`)
-                }
-                break;
-        }
+		switch (this._Controller.settings.MeadowEndpointsSessionDataSource || 'Request')
+		{
+			default:
+				this._Controller.log.warn(`Unknown session source configured: ${this._Controller.settings.MeadowEndpointsSessionDataSource} - defaulting to Request for backward compatibility`);
+			case 'Request':
+				// noop - already set by orator-session
+				tmpSession = this._Controller.extend(tmpSession, pRequest.UserSession);
+				break;
+			case 'None':
+				break;
+			case 'Header':
+				try
+				{
+					tmpHeaderSessionString = pRequest.headers['x-trusted-session'];
+					if (!tmpHeaderSessionString)
+					{
+						break;
+					}
+					const tmpHeaderSession = JSON.parse(tmpHeaderSessionString);
+					tmpSession = this._Controller.extend(tmpSession, tmpHeaderSession);
+				}
+				catch (pError)
+				{
+					this._Controller.log.error(`Meadow Endpoints attempted to process a Header Session String with value [${tmpHeaderSessionString}] and failed -- likely culprit is bad JSON.`)
+				}
+				break;
+		}
 
-        // Do we keep this here for backwards compatibility?
-        // Yes this makes sense here.
-        pRequest.UserSession = tmpSession;
+		// Do we keep this here for backwards compatibility?
+		// Yes this makes sense here.
+		pRequest.UserSession = tmpSession;
 
-        return tmpSession;
-    }
+		return tmpSession;
+	}
 }
 
 module.exports = MeadowEndpointsSessionMarshaler;

package/source/controller/utility/Meadow-Endpoints-Stream-RecordArray.js

@@ -6,13 +6,13 @@ const JSONStream = require('JSONStream');
 
 class MeadowEndpointsStreamRecordArray
 {
-    /**
-     * @param {import('../Meadow-Endpoints-Controller-Base.js')} pController
-     */
-    constructor(pController)
+	/**
+	 * @param {import('../Meadow-Endpoints-Controller-Base.js')} pController
+	 */
+	constructor(pController)
 	{
-        this._Controller = pController;
-    }
+		this._Controller = pController;
+	}
 
 	chunk(pInput, pChunkSize, pChunkCache)
 	{

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/create/Meadow-Operation-Create.js

@@ -19,7 +19,7 @@ const doCreate = function(pRecord, pRequest, pRequestState, pResponse, fCallback
 			tmpRequestState.RecordToCreate = pRecord;
 
 			//Make sure record gets created with a customerID
-			if (!tmpRequestState.RecordToCreate.hasOwnProperty('IDCustomer') && this.DAL.jsonSchema.properties.hasOwnProperty('IDCustomer'))
+			if (!tmpRequestState.RecordToCreate.hasOwnProperty('IDCustomer') && this.DAL.jsonSchema && this.DAL.jsonSchema.properties && this.DAL.jsonSchema.properties.hasOwnProperty('IDCustomer'))
 			{
 				tmpRequestState.RecordToCreate.IDCustomer = tmpRequestState.SessionData.CustomerID || 0;
 			}

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/schema/Meadow-Endpoint-Validate.js

@@ -27,7 +27,7 @@ const doAPIEndpointValidate = function(pRequest, pResponse, fNext)
 			(fStageComplete) =>
 			{
 				pResponse.send(tmpRequestState.RecordValidation);
-				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Validated Record for ${this.DAL.scope} - ${tmpRequestState.RecordValidation}`);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Validated Record for ${this.DAL.scope} - ${JSON.stringify(tmpRequestState.RecordValidation)}`);
 				return fStageComplete();
 			}
 		],

package/source/endpoints/update/Meadow-Endpoint-BulkUpdate.js

@@ -23,6 +23,7 @@ const doAPIEndpointUpdate = function(pRequest, pResponse, fNext)
 
 				return fStageComplete();
 			},
+			fBehaviorInjector(`UpdateBulk-PreOperation`),
 			(fStageComplete) =>
 			{
 				this.eachLimit(tmpRequestState.BulkRecords, 1,
@@ -31,6 +32,7 @@ const doAPIEndpointUpdate = function(pRequest, pResponse, fNext)
 						doUpdate.call(this, pRecord, pRequest, tmpRequestState, pResponse, fCallback);
 					}, fStageComplete);
 			},
+			fBehaviorInjector(`UpdateBulk-PostOperation`),
 			(fStageComplete) =>
 			{
 				return this.doStreamRecordArray(pResponse, tmpRequestState.UpdatedRecords, fStageComplete);

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();
 					});
 			}
@@ -58,6 +66,7 @@ const doUpdate = function(pRecordToModify, pRequest, pRequestState, pResponse, f
 			tmpRequestState.Query = this.DAL.query;
 			return fStageComplete();
 		},
+		fBehaviorInjector(`Update-PreOperation`),
 		(fStageComplete) =>
 		{
 			tmpRequestState.Query.setIDUser(tmpRequestState.SessionData.UserID);
@@ -65,6 +74,7 @@ const doUpdate = function(pRecordToModify, pRequest, pRequestState, pResponse, f
 
 			return fStageComplete();
 		},
+		fBehaviorInjector(`Update-QueryConfiguration`),
 		(fStageComplete) =>
 		{
 			this.DAL.doUpdate(tmpRequestState.Query,

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

@@ -28,6 +28,7 @@ const doAPIEndpointUpserts = function(pRequest, pResponse, fNext)
 
 				return fStageComplete();
 			},
+			fBehaviorInjector(`UpsertBulk-PreOperation`),
 			(fStageComplete) =>
 			{
 				this.eachLimit(tmpRequestState.BulkRecords, 1,
@@ -36,13 +37,14 @@ const doAPIEndpointUpserts = function(pRequest, pResponse, fNext)
 						doUpsert.call(this, pRecord, pRequest, tmpRequestState, pResponse, fCallback);
 					}, fStageComplete);
 			},
+			fBehaviorInjector(`UpsertBulk-PostOperation`),
 			(fStageComplete) =>
 			{
 				return this.doStreamRecordArray(pResponse, marshalLiteList.call(this, tmpRequestState.UpsertedRecords, pRequest), fStageComplete);
 			},
 			(fStageComplete) =>
 			{
-				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Bulk upsert complete -- ${tmpRequestState.UpsertedRecords} records processed`);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Bulk upsert complete -- ${tmpRequestState.UpsertedRecords.length} records processed`);
 				return fStageComplete();
 			}
 		], (pError) =>