meadow-endpoints 3.0.7 → 4.0.3

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

@@ -0,0 +1,85 @@
+/**
+* Meadow Endpoint - Read a list of lite Records (for Drop-downs and such)
+*/
+const marshalLiteList = require('./Meadow-Marshal-LiteList.js');
+
+const doAPIEndpointReadLite = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadsLite');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			// 1a. Get the records
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				// TODO: Limit the query to the columns we need for the templated expression
+
+				var tmpCap = false;
+				var tmpBegin = false;
+				if (typeof(pRequest.params.Begin) === 'string' ||
+					typeof(pRequest.params.Begin) === 'number')
+				{
+					tmpBegin = parseInt(pRequest.params.Begin, 10);
+				}
+				if (typeof(pRequest.params.Cap) === 'string' ||
+					typeof(pRequest.params.Cap) === 'number')
+				{
+					tmpCap = parseInt(pRequest.params.Cap, 10);
+				}
+				else
+				{
+					//maximum number of records to return by default on Read queries. Override via "MeadowDefaultMaxCap" fable setting.
+					tmpCap = (this.settings['MeadowDefaultMaxCap']) || 250;
+				}
+				tmpRequestState.Query.setCap(tmpCap).setBegin(tmpBegin);
+				if (typeof(pRequest.params.Filter) === 'string')
+				{
+					// If a filter has been passed in, parse it and add the values to the query.
+					this.parseFilter(pRequest.params.Filter, tmpRequestState.Query);
+				}
+				else if (pRequest.params.Filter)
+				{
+					tmpRequestState.Query.setFilter(pRequest.params.Filter);
+				}
+
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Reads-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doReads(tmpRequestState.Query, fStageComplete);
+			},
+			(pQuery, pRecords, fStageComplete) =>
+			{
+				if (pRecords.length < 1)
+				{
+					pRecords = [];
+				}
+				tmpRequestState.RawRecords = pRecords;
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.Records = marshalLiteList.call(this, tmpRequestState.RawRecords, pRequest, (typeof(pRequest.params.ExtraColumns) === 'string') ? pRequest.params.ExtraColumns.split(',') : []);
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				return this.doStreamRecordArray(pResponse, tmpRequestState.Records, fNext);
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read a recordset lite list with ${tmpRequestState.Records.length} results`);
+				return fStageComplete();
+			}
+		],
+		(pError, pResultRecords) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointReadLite;

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

@@ -0,0 +1,55 @@
+/**
+* Meadow Endpoint - Read the Max Value of a Column in a Set
+*/
+const doAPIEndpointReadMax = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadMax');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.ColumnName =  pRequest.params.ColumnName;
+				tmpRequestState.Query.setSort({Column:tmpRequestState.ColumnName, Direction:'Descending'});
+				tmpRequestState.Query.setCap(1);
+
+				return fStageComplete();
+			},
+			fBehaviorInjector(`ReadMax-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doRead(tmpRequestState.Query, fStageComplete);
+			},
+			(pQuery, pRecord, fStageComplete) =>
+			{
+				if (!pRecord)
+				{
+					return fStageComplete(this.ErrorHandler.getError('Record not Found', 404));
+				}
+				tmpRequestState.Record = pRecord;
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				this.BehaviorInjection.runBehavior(`ReadMax-PostOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read max record of ${this.DAL.scope} on ${tmpRequestState.ColumnName}`);
+				pResponse.send(tmpRequestState.Record);
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointReadMax;

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

@@ -0,0 +1,89 @@
+/**
+* Meadow Endpoint - Read a select list of Records (for Drop-downs and such)
+*/
+const doAPIEndpointReadSelectList = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadsBy');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+
+				var tmpCap = false;
+				var tmpBegin = false;
+				if (typeof(pRequest.params.Begin) === 'string' ||
+					typeof(pRequest.params.Begin) === 'number')
+				{
+					tmpBegin = parseInt(pRequest.params.Begin);
+				}
+				if (typeof(pRequest.params.Cap) === 'string' ||
+					typeof(pRequest.params.Cap) === 'number')
+				{
+					tmpCap = parseInt(pRequest.params.Cap);
+				}
+				else
+				{
+					tmpCap = (this.settings['MeadowDefaultMaxCap']) || 250;
+				}
+				tmpRequestState.Query.setCap(tmpCap).setBegin(tmpBegin);
+				if (typeof(pRequest.params.Filter) === 'string')
+				{
+					this.parseFilter(pRequest.params.Filter, tmpRequestState.Query);
+				}
+
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Reads-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doReads(tmpRequestState.Query, fStageComplete);
+			},
+			(pQuery, pRecords, fStageComplete) =>
+			{
+				if (pRecords.length < 1)
+				{
+					pRecords = [];
+				}
+
+				tmpRequestState.Records = pRecords;
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.SelectList = [];
+
+				for (var i = 0; i < tmpRequestState.Records.length; i++)
+				{
+					tmpRequestState.SelectList.push
+					(
+						{
+							Hash: tmpRequestState.Records[i][this.DAL.defaultIdentifier],
+							Value: this.BehaviorInjection.processTemplate('SelectList', {Record:tmpRequestState.Records[i]}, this.DAL.scope+' #<%= Record.'+this.DAL.defaultIdentifier+'%>')
+						}
+					);
+				}
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				return this.doStreamRecordArray(pResponse, tmpRequestState.SelectList, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read a recordset lite list with ${tmpRequestState.SelectList.length} results.`);
+				return fStageComplete();
+			}
+		],
+		(pError, pResultRecords) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointReadSelectList;

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

@@ -0,0 +1,75 @@
+/**
+* Meadow Endpoint - Read a Set of Records
+*/
+const doAPIEndpointReads = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Reads');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+	[
+		(fStageComplete) =>
+		{
+			tmpRequestState.Query = this.DAL.query;
+
+			var tmpCap = false;
+			var tmpBegin = false;
+			if (typeof(pRequest.params.Begin) === 'string' ||
+				typeof(pRequest.params.Begin) === 'number')
+			{
+				tmpBegin = parseInt(pRequest.params.Begin);
+			}
+			if (typeof(pRequest.params.Cap) === 'string' ||
+				typeof(pRequest.params.Cap) === 'number')
+			{
+				tmpCap = parseInt(pRequest.params.Cap);
+			}
+			else
+			{
+				tmpCap = (this.settings['MeadowDefaultMaxCap']) || 250;
+			}
+			tmpRequestState.Query.setCap(tmpCap).setBegin(tmpBegin);
+			if (typeof(pRequest.params.Filter) === 'string')
+			{
+				// If a filter has been passed in, parse it and add the values to the query.
+				this.parseFilter(pRequest.params.Filter, tmpRequestState.Query);
+			}
+			else if (pRequest.params.Filter)
+			{
+				tmpRequestState.Query.setFilter(pRequest.params.Filter);
+			}
+
+			return fStageComplete();
+		},
+		fBehaviorInjector(`Reads-QueryConfiguration`),
+		(fStageComplete) =>
+		{
+			this.DAL.doReads(tmpRequestState.Query, fStageComplete);
+		},
+		(pQuery, pRecords, fStageComplete) =>
+		{
+			if (!pRecords)
+			{
+				return fStageComplete(this.ErrorHandler.getError('No records found.', 404));
+			}
+			tmpRequestState.Records = pRecords;
+			return fStageComplete();
+		},
+		fBehaviorInjector(`Reads-PostOperation`),
+		(fStageComplete) =>
+		{
+			this.doStreamRecordArray(pResponse, tmpRequestState.Records, fStageComplete);
+		},
+		(fStageComplete) =>
+		{
+			this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, 'Read a list of records.');
+			return fStageComplete();
+		}
+	],
+	(pError) =>
+	{
+		return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+	});
+};
+
+module.exports = doAPIEndpointReads;

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

@@ -0,0 +1,100 @@
+/**
+* Meadow Endpoint - Read a Record
+*/
+const doAPIEndpointReadsBy = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadsBy');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			// 1. Construct the Query
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+
+				var tmpCap = false;
+				var tmpBegin = false;
+				if (typeof(pRequest.params.Begin) === 'string' ||
+					typeof(pRequest.params.Begin) === 'number')
+				{
+					tmpBegin = parseInt(pRequest.params.Begin);
+				}
+				if (typeof(pRequest.params.Cap) === 'string' ||
+					typeof(pRequest.params.Cap) === 'number')
+				{
+					tmpCap = parseInt(pRequest.params.Cap);
+				}
+				else
+				{
+					//maximum number of records to return by default on Read queries. Override via "MeadowDefaultMaxCap" fable setting.
+					tmpCap = (this.settings['MeadowDefaultMaxCap']) || 250;
+				}
+				tmpRequestState.Query.setCap(tmpCap).setBegin(tmpBegin);
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				function addField(pByField, pByValue)
+				{
+					if (pByValue.constructor === Array)
+					{
+						tmpRequestState.Query.addFilter(pByField, pByValue, 'IN', 'AND', 'RequestByField');
+					}
+					else
+					{
+						tmpRequestState.Query.addFilter(pByField, pByValue, '=', 'AND', 'RequestByField');
+					}
+				}
+
+				var tmpFilters = pRequest.params.Filters;
+				if (tmpFilters &&
+					tmpFilters.constructor === Array)
+				{
+					tmpFilters.forEach(function(filter)
+					{
+						addField(filter.ByField, filter.ByValue);
+					});
+				}
+				else
+				{
+					addField(pRequest.params.ByField, pRequest.params.ByValue);
+				}
+
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Reads-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doReads(tmpRequestState.Query,
+					(pError, pQuery, pRecords) =>
+					{
+						if (!pRecords)
+						{
+							return fStageComplete(this.ErrorHandler.getError('No records found.', 404));
+						}
+						tmpRequestState.Records = pRecords;
+						return fStageComplete();
+					});
+			},
+			fBehaviorInjector(`Reads-PostOperation`),
+			(fStageComplete) =>
+			{
+				return this.doStreamRecordArray(pResponse, tmpRequestState.Records, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read a list of records by ${pRequest.params.ByField} = ${pRequest.params.ByValue}`);
+				return fStageComplete();
+			}
+		],
+		// 7. Return the results to the user
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointReadsBy;

package/source/{crud → endpoints/read}/Meadow-Marshal-DistinctList.js

@@ -1,16 +1,7 @@
 /**
-* Meadow Operation - Marshal an array of records into a lite list
-*
-* @license MIT
-*
-* @author Steven Velozo <steven@velozo.com>
-* @module Meadow
+* Meadow Operation - Marshal an array of records into a distinct list
 */
-/**
-* Shared record marshaling code
-*/
-
-var marshalDistinctList = (pRecords, pRequest, pFieldList) =>
+const marshalDistinctList = function(pRecords, pRequest, pFieldList)
 {
 	if (pRecords.length < 1)
 		return [];
@@ -20,7 +11,7 @@ var marshalDistinctList = (pRecords, pRequest, pFieldList) =>
 	let tmpFieldList = (typeof(pFieldList) !== 'undefined') ? pFieldList : [];
 
 	// See if this record has a GUID in the schema
-	let tmpGUID = (pRequest.DAL.defaultGUIdentifier && pRequest.DAL.defaultGUIdentifier.length > 0) ? pRequest.DAL.defaultGUIdentifier : false;
+	let tmpGUID = (this.DAL.defaultGUIdentifier && this.DAL.defaultGUIdentifier.length > 0) ? this.DAL.defaultGUIdentifier : false;
 	// Peek at the first record to check for updatedate
 	let tmpHasUpdateDate = (pRecords[0].hasOwnProperty('UpdateDate')) ? true : false;
 	//Include all GUID and ID fields on the record
@@ -52,4 +43,4 @@ var marshalDistinctList = (pRecords, pRequest, pFieldList) =>
 	return tmpDistinctList;
 };
 
-module.exports = marshalDistinctList;
+module.exports = marshalDistinctList;

package/source/{crud → endpoints/read}/Meadow-Marshal-LiteList.js

@@ -1,16 +1,7 @@
 /**
 * Meadow Operation - Marshal an array of records into a lite list
-*
-* @license MIT
-*
-* @author Steven Velozo <steven@velozo.com>
-* @module Meadow
 */
-/**
-* Shared record marshaling code
-*/
-
-var marshalLiteList = (pRecords, pRequest, pFieldList) =>
+const marshalLiteList = function(pRecords, pRequest, pFieldList)
 {
 	if (pRecords.length < 1)
 		return [];
@@ -20,7 +11,7 @@ var marshalLiteList = (pRecords, pRequest, pFieldList) =>
 	let tmpFieldList = (typeof(pFieldList) !== 'undefined') ? pFieldList : [];
 
 	// See if this record has a GUID in the schema
-	let tmpGUID = (pRequest.DAL.defaultGUIdentifier && pRequest.DAL.defaultGUIdentifier.length > 0) ? pRequest.DAL.defaultGUIdentifier : false;
+	let tmpGUID = (this.DAL.defaultGUIdentifier && this.DAL.defaultGUIdentifier.length > 0) ? this.DAL.defaultGUIdentifier : false;
 	// Peek at the first record to check for updatedate
 	let tmpHasUpdateDate = (pRecords[0].hasOwnProperty('UpdateDate')) ? true : false;
 	//Include all GUID and ID fields on the record
@@ -50,9 +41,9 @@ var marshalLiteList = (pRecords, pRequest, pFieldList) =>
 	{
 		let tmpLiteRecord = (
 			{
-				Value: pRequest.BehaviorModifications.processTemplate('SelectList', {Record:pRecords[i]}, pRequest.DAL.scope+' #<%= Record.'+pRequest.DAL.defaultIdentifier+'%>')
+				Value: this.BehaviorInjection.processTemplate('SelectList', {Record:pRecords[i]}, this.DAL.scope+' #<%= Record.'+this.DAL.defaultIdentifier+'%>')
 			});
-		tmpLiteRecord[pRequest.DAL.defaultIdentifier] = pRecords[i][pRequest.DAL.defaultIdentifier];
+		tmpLiteRecord[this.DAL.defaultIdentifier] = pRecords[i][this.DAL.defaultIdentifier];
 
 		if (tmpGUID)
 			tmpLiteRecord[tmpGUID] = pRecords[i][tmpGUID];
@@ -71,4 +62,4 @@ var marshalLiteList = (pRecords, pRequest, pFieldList) =>
 	return tmpLiteList;
 };
 
-module.exports = marshalLiteList;
+module.exports = marshalLiteList;

package/source/endpoints/schema/Meadow-Endpoint-New.js

@@ -0,0 +1,36 @@
+/**
+* Meadow Endpoint - Get a New, empty Record
+*/
+const doAPIEndpointNew = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'New');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			fBehaviorInjector(`New-PreOperation`),
+			(fStageComplete) =>
+			{
+				// If during the PreOperation this was set, we can
+				if (!tmpRequestState.EmptyEntityRecord)
+				{
+					tmpRequestState.EmptyEntityRecord = this.extend({}, this.DAL.schemaFull.defaultObject);
+				}
+				return fStageComplete();
+			},
+			fBehaviorInjector(`New-PostOperation`),
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.EmptyEntityRecord);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Delivered New ${this.DAL.scope} Record`);
+				return fStageComplete();
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointNew;

package/source/endpoints/schema/Meadow-Endpoint-Schema.js

@@ -0,0 +1,36 @@
+/**
+* Meadow Endpoint - Get the Record Schema
+*/
+const doAPIEndpointSchema = function (pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Schema');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			fBehaviorInjector(`Schema-PreOperation`),
+			(fStageComplete) =>
+			{
+				// If during the PreOperation this was set, we won't overwrite
+				if (!pRequest.JSONSchema)
+				{
+					tmpRequestState.JSONSchema = this.extend({}, this.DAL.jsonSchema);
+				}
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Schema-PostOperation`),
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.JSONSchema);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Delivered JSONSchema for ${this.DAL.scope}`);
+				return fStageComplete();
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointSchema;

package/source/endpoints/schema/Meadow-Endpoint-Validate.js

@@ -0,0 +1,41 @@
+/**
+* Meadow Endpoint - Validate a Record
+*/
+const doAPIEndpointValidate = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Validate');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			fBehaviorInjector(`Validate-PreOperation`),
+			(fStageComplete) =>
+			{
+				if (typeof(pRequest.body) !== 'object')
+				{
+					return fStageComplete(this.ErrorHandler.getError('Record validate failure - a valid JSON object is required.', 500));
+				}
+				tmpRequestState.Record = pRequest.body;
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.RecordValidation = this.DAL.schemaFull.validateObject(tmpRequestState.Record);
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Validate-PostOperation`),
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.RecordValidation);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Validated Record for ${this.DAL.scope} - ${tmpRequestState.RecordValidation}`);
+				return fStageComplete();
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointValidate;

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

@@ -0,0 +1,50 @@
+/**
+* Meadow Endpoint - Update a set of Records
+*/
+const doUpdate = require('./Meadow-Operation-Update.js');
+
+const doAPIEndpointUpdate = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'UpdateBulk');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	tmpRequestState.UpdatedRecords = [];
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				if (!Array.isArray(pRequest.body))
+				{
+					return fStageComplete(this.ErrorHandler.getError('Record update failure - a valid record is required.', 500));
+				}
+
+				tmpRequestState.BulkRecords = pRequest.body;
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				this.eachLimit(tmpRequestState.BulkRecords, 1,
+					(pRecord, fCallback) =>
+					{
+						doUpdate.call(this, pRecord, pRequest, tmpRequestState, pResponse, fCallback);
+					}, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				return this.doStreamRecordArray(pResponse, tmpRequestState.UpdatedRecords, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Bulk updated ${tmpRequestState.UpdatedRecords.length} records`);
+				return fStageComplete();
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		});
+};
+
+module.exports = doAPIEndpointUpdate;