meadow-endpoints 3.0.7 → 4.0.2

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;

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

@@ -0,0 +1,58 @@
+/**
+* Meadow Endpoint - Update a Record
+*/
+const doUpdate = require('./Meadow-Operation-Update.js');
+
+const doAPIEndpointUpdate = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Update');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+	[
+		(fStageComplete) =>
+		{
+			if (typeof(pRequest.body) !== 'object')
+			{
+				return fStageComplete(this.ErrorHandler.getError('Record update failure - a valid record is required.', 400));
+			}
+			if (pRequest.body[this.DAL.defaultIdentifier] < 1)
+			{
+				return fStageComplete(this.ErrorHandler.getError('Record update failure - a valid record ID is required in the passed-in record.', 400));
+			}
+
+			tmpRequestState.Record = pRequest.body;
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			doUpdate.call(this, pRequest.body, pRequest, tmpRequestState, pResponse, fStageComplete);
+		},
+		(fStageComplete) =>
+		{
+			if (tmpRequestState.RecordUpdateError)
+			{
+				return fStageComplete(tmpRequestState.RecordUpdateErrorObject);
+			}
+			if (tmpRequestState.UpdatedRecords.length < 1)
+			{
+				return fStageComplete(this.ErrorHandler.getError('Unknown record update failure - no updated records returned.', 500));
+			}
+
+			tmpRequestState.Record = tmpRequestState.UpdatedRecords[0];
+
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			pResponse.send(tmpRequestState.Record);
+			return fStageComplete();
+		}
+	],
+	(pError) =>
+	{
+		return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+	});
+};
+
+module.exports = doAPIEndpointUpdate;

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

@@ -0,0 +1,115 @@
+/**
+* Meadow Operation - Update a record
+*/
+const doUpdate = function(pRecordToModify, pRequest, pRequestState, pResponse, fCallback, pOptionalCachedUpdatingRecord)
+{
+	// This is a virtual operation
+	let tmpRequestState = this.cloneAsyncSafeRequestState(pRequestState, 'doUpdate');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	// If there is not a default identifier or cached record, fail
+	if ((pRecordToModify[this.DAL.defaultIdentifier] < 1) && (typeof(pOptionalCachedUpdatingRecord) === 'undefined'))
+	{
+		return fCallback('Record update failure - a valid record ID is required in the passed-in record.');
+	}
+
+	if (!Array.isArray(tmpRequestState.ParentRequestState.UpdatedRecords))
+	{
+		tmpRequestState.ParentRequestState.UpdatedRecords = [];
+	}
+
+	this.waterfall(
+	[
+		(fStageComplete) =>
+		{
+			tmpRequestState.RecordToModify = pRecordToModify;
+
+			if (typeof(pOptionalCachedUpdatingRecord) !== 'undefined')
+			{
+				// Use the cached updating record instead of reading a record.
+				tmpRequestState.OriginalRecord = pOptionalCachedUpdatingRecord;
+				return fStageComplete();
+			}
+			else
+			{
+				tmpRequestState.Query = this.DAL.query;
+
+				tmpRequestState.Query.addFilter(this.DAL.defaultIdentifier, tmpRequestState.RecordToModify[this.DAL.defaultIdentifier]);
+
+				// Load the record so we can do security checks on it
+				this.DAL.doRead(tmpRequestState.Query,
+					(pError, pQuery, pRecord) =>
+					{
+						if (pError)
+						{
+							return fStageComplete(pError);
+						}
+						if (!pRecord)
+						{
+							return fStageComplete(this.ErrorHandler.getError('Record not Found', 404));
+						}
+						tmpRequestState.Record = pRecord;
+						return fStageComplete();
+					});
+			}
+		},
+		(fStageComplete) =>
+		{
+			tmpRequestState.Query = this.DAL.query;
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			tmpRequestState.Query.setIDUser(tmpRequestState.SessionData.UserID);
+			tmpRequestState.Query.addRecord(tmpRequestState.RecordToModify);
+
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			this.DAL.doUpdate(tmpRequestState.Query,
+				(pError, pQuery, pReadQuery, pRecord) =>
+				{
+					if (pError)
+					{
+						if (typeof(pError) == 'string')
+						{
+							return fStageComplete(this.ErrorHandler.getError(pError, 500));
+						}
+						else
+						{
+							return fStageComplete(pError);
+						}
+					}
+					if (!pRecord)
+					{
+						return fStageComplete(this.ErrorHandler.getError(`Error in DAL Update: No record returned from persistence engine.`, 500));
+					}
+					tmpRequestState.Record = pRecord;
+					return fStageComplete();
+				});
+		},
+		(fStageComplete) => { return this.BehaviorInjection.runBehavior(`Update-PostOperation`, this, pRequest, tmpRequestState, fStageComplete); },
+		(fStageComplete) =>
+		{
+			tmpRequestState.ParentRequestState.UpdatedRecords.push(tmpRequestState.Record);
+			this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Updated record with ID ${tmpRequestState.Record[this.DAL.defaultIdentifier]}`);
+			return fStageComplete();
+		}
+	], (pError) =>
+	{
+		if (pError)
+		{
+			tmpRequestState.Record.Error = pError;
+
+			tmpRequestState.ParentRequestState.RecordUpdateError = true;
+			tmpRequestState.ParentRequestState.RecordUpdateErrorObject = pError;
+
+			tmpRequestState.ParentRequestState.UpdatedRecords.push(tmpRequestState.Record);
+		}
+
+		return fCallback();
+	});
+};
+
+module.exports = doUpdate;

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

@@ -0,0 +1,52 @@
+/**
+* Meadow Endpoint - Upsert a set of Records
+*/
+const doUpsert = require('./Meadow-Operation-Upsert.js');
+
+const marshalLiteList = require('../read/Meadow-Marshal-LiteList.js');
+
+const doAPIEndpointUpserts = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'UpsertBulk');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	tmpRequestState.CreatedRecords = [];
+	tmpRequestState.UpdatedRecords = [];
+	tmpRequestState.UpsertedRecords = [];
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				if (!Array.isArray(pRequest.body))
+				{
+					return fStageComplete(this.ErrorHandler.getError(`Record bulk upsert failure - a valid array of records is required.`, 500));
+				}
+
+				tmpRequestState.BulkRecords = pRequest.body;
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				this.eachLimit(tmpRequestState.BulkRecords, 1,
+					(pRecord, fCallback) =>
+					{
+						doUpsert.call(this, pRecord, pRequest, tmpRequestState, pResponse, fCallback);
+					}, fStageComplete);
+			},
+			(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`);
+				return fStageComplete();
+			}
+		], (pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		});
+};
+module.exports = doAPIEndpointUpserts;

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

@@ -0,0 +1,57 @@
+/**
+* Meadow Endpoint - Upsert (Insert OR Update) a Record
+*/
+var doUpsert = require('./Meadow-Operation-Upsert.js');
+
+var doAPIEndpointUpsert = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Upsert');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	// Configure the request for the generic create & update operations
+	tmpRequestState.CreatedRecords = [];
+	tmpRequestState.UpdatedRecords = [];
+	tmpRequestState.UpsertedRecords = [];
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				//1. Validate request body to ensure it is a valid record
+				if (typeof(pRequest.body) !== 'object')
+				{
+					return fStageComplete(this.ErrorHandler.getError('Record upsert failure - a valid record is required.', 500));
+				}
+
+				tmpRequestState.RecordToUpsert = pRequest.body;
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				doUpsert.call(this, tmpRequestState.RecordToUpsert, pRequest, tmpRequestState, pResponse, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				if (tmpRequestState.RecordUpsertError)
+				{
+					return fStageComplete(tmpRequestState.RecordUpsertErrorMessage);
+				}
+				if (tmpRequestState.UpsertedRecords.length < 1)
+				{
+					return fStageComplete(this.ErrorHandler.getError('Record upsert unknown failure - no record back from Upsert operation.', 500));
+				}
+
+				tmpRequestState.Record = tmpRequestState.UpsertedRecords[0];
+
+				pResponse.send(tmpRequestState.Record);
+
+				return fStageComplete();
+			}
+		], (pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		});
+};
+
+module.exports = doAPIEndpointUpsert;