meadow-endpoints 3.0.7 → 4.0.3

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,53 @@
+/**
+* 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 = [];
+	tmpRequestState.ErrorRecords = [];
+
+	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,58 @@
+/**
+* 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 = [];
+	tmpRequestState.ErrorRecords = [];
+
+	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;

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

@@ -0,0 +1,132 @@
+/**
+* Meadow Operation - Upsert a record
+*/
+const doCreate = require('../create/Meadow-Operation-Create.js');
+const doUpdate = require('../update/Meadow-Operation-Update.js');
+
+const doUpsert = function(pRecordToUpsert, pRequest, pRequestState, pResponse, fCallback)
+{
+	let tmpRequestState = this.cloneAsyncSafeRequestState(pRequestState, 'Upsert');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+
+				// Prepare to gather requirements for upserting
+				tmpRequestState.Record = pRecordToUpsert;
+
+				// This operation will be create only if there is no GUID or ID in the record bundle
+				tmpRequestState.UpsertCreateOnly = true;
+
+				// See if there is a default identifier or default GUIdentifier
+				if ((typeof(tmpRequestState.Record[this.DAL.defaultGUIdentifier]) !== 'undefined') && tmpRequestState.Record[this.DAL.defaultGUIdentifier].length > 0)
+				{
+					tmpRequestState.Query.addFilter(this.DAL.defaultGUIdentifier, tmpRequestState.Record[this.DAL.defaultGUIdentifier]);
+					tmpRequestState.UpsertCreateOnly = false;
+				}
+				if ((typeof(tmpRequestState.Record[this.DAL.defaultIdentifier]) !== 'undefined') && (tmpRequestState.Record[this.DAL.defaultIdentifier] > 0))
+				{
+					tmpRequestState.Query.addFilter(this.DAL.defaultIdentifier, tmpRequestState.Record[this.DAL.defaultIdentifier]);
+					tmpRequestState.UpsertCreateOnly = false;
+				}
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				if (tmpRequestState.UpsertCreateOnly)
+				{
+					tmpRequestState.Operation = 'Create';
+					doCreate.call(this, tmpRequestState.Record, pRequest, tmpRequestState, pResponse, fStageComplete);
+				}
+				else
+				{
+					this.DAL.doRead(tmpRequestState.Query,
+						(pError, pQuery, pRecord) =>
+						{
+							if (pError)
+							{
+								if (typeof(pError) == 'string')
+								{
+									return fStageComplete(this.ErrorHandler.getError(pError, 500));
+								}
+								else
+								{
+									return fStageComplete(pError);
+								}
+							}
+							else if (!pRecord)
+							{
+								// Record not found -- do a create.
+								tmpRequestState.Operation = 'Create';
+								doCreate.call(this, tmpRequestState.Record, pRequest, tmpRequestState, pResponse, fStageComplete);
+							}
+							else
+							{
+								// Set the default ID in the passed-in record if it doesn't exist..
+								if (!tmpRequestState.Record.hasOwnProperty(this.DAL.defaultIdentifier))
+								{
+									tmpRequestState.Record[this.DAL.defaultIdentifier] = pRecord[this.DAL.defaultIdentifier];
+								}
+								// If the found record does not match the passed ID --- what the heck?!
+								if (tmpRequestState.Record[this.DAL.defaultIdentifier] != pRecord[this.DAL.defaultIdentifier])
+								{
+									return fStageComplete(this.ErrorHandler.getError('Record IDs do not match', 500));
+								}
+								// Record found -- do an update.  Use the cached record, though.
+								tmpRequestState.Operation = 'Update';
+								doUpdate.call(this, tmpRequestState.Record, pRequest, tmpRequestState, pResponse, fStageComplete, pRecord);
+							}
+						});
+				}
+			},
+			(fStageComplete) =>
+			{
+				// Now stuff the record into the upserted array
+				if (tmpRequestState.Operation == 'Update')
+				{
+					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];
+				}
+				else if (tmpRequestState.Operation == 'Create')
+				{
+					if (tmpRequestState.RecordCreateError)
+					{
+						return fStageComplete(tmpRequestState.RecordCreateErrorObject);
+					}
+					if (tmpRequestState.CreatedRecords.length < 1)
+					{
+						return fStageComplete(this.ErrorHandler.getError('Unknown record create failure - no created records returned.', 500));
+					}
+		
+					tmpRequestState.Record = tmpRequestState.CreatedRecords[0];
+				}
+				else
+				{
+					return fStageComplete(this.ErrorHandler.getError('Unkknown record upsert failure = no records returned from doUpsert.', 500));
+				}
+				tmpRequestState.ParentRequestState.UpsertedRecords.push(tmpRequestState.Record);
+				return fStageComplete();
+			}
+		], (pError) =>
+		{
+			if (pError)
+			{
+				tmpRequestState.Record.Error = pError;
+			}
+			return fCallback();
+		});
+};
+
+module.exports = doUpsert;