meadow-endpoints 3.0.7 → 4.0.3

package/source/endpoints/count/Meadow-Endpoint-Count.js

@@ -0,0 +1,49 @@
+/**
+* Meadow Endpoint - Count a Record
+*/
+const doAPIEndpointCount = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Count');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				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(`Count-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doCount(tmpRequestState.Query,
+					(pError, pQuery, pCount) =>
+					{
+						tmpRequestState.Result = {Count:pCount};
+						return fStageComplete(pError);
+					});
+			},
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.Result);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Delivered recordset count of ${tmpRequestState.Result.Count} for ${this.DAL.scope}.`);
+				return fStageComplete();
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointCount;

package/source/endpoints/count/Meadow-Endpoint-CountBy.js

@@ -0,0 +1,40 @@
+/**
+* Meadow Endpoint - Count a Record filtered by a single value
+*/
+const doAPIEndpointCountBy = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'CountBy');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				tmpRequestState.Query.addFilter(pRequest.params.ByField, pRequest.params.ByValue, '=', 'AND', 'RequestByField');
+				return fStageComplete();
+			},
+			fBehaviorInjector(`CountBy-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doCount(tmpRequestState.Query,
+					(pError, pQuery, pCount) =>
+					{
+						tmpRequestState.Result = {Count:pCount};
+						return fStageComplete(pError);
+					});
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, 'Delivered recordset count of '+tmpRequestState.Result.Count+'.');
+				pResponse.send(tmpRequestState.Result);
+				return fStageComplete();
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		});
+};
+
+module.exports = doAPIEndpointCountBy;

package/source/endpoints/create/Meadow-Endpoint-BulkCreate.js

@@ -0,0 +1,53 @@
+/**
+* Meadow Endpoint - Create a set of Record in Bulk
+*/
+
+const doCreate = require('./Meadow-Operation-Create.js');
+
+const doAPIEndpointBulkCreate = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'CreateBulk');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	tmpRequestState.CreatedRecords = [];
+
+	this.waterfall(
+	[
+		(fStageComplete) =>
+		{
+			if (!Array.isArray(pRequest.body))
+			{
+				return fStageComplete(this.ErrorHandler.getError('Bulk record create failure - a valid array of records to create is required.', 500));
+			}
+			pRequest.RecordsToBulkCreate = pRequest.body;
+
+			return fStageComplete();
+		},
+		fBehaviorInjector(`CreateBulk-PreOperation`),
+		(fStageComplete) =>
+		{
+			// TODO: Research parallelism opportunities from custom routes
+			this.eachLimit(pRequest.RecordsToBulkCreate, 1,
+				(pRecord, fCallback) =>
+				{
+					doCreate.call(this, pRecord, pRequest, tmpRequestState, pResponse, fCallback);
+				}, fStageComplete);
+		},
+		fBehaviorInjector(`CreateBulk-PostOperation`),
+		(fStageComplete) =>
+		{
+			return this.doStreamRecordArray(pResponse, tmpRequestState.CreatedRecords, fStageComplete);
+		},
+		(fStageComplete) =>
+		{
+			this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Bulk created ${tmpRequestState.CreatedRecords.length} records`);
+			return fStageComplete();
+		}
+	],
+	(pError) =>
+	{
+		return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+	});
+};
+
+module.exports = doAPIEndpointBulkCreate;

package/source/endpoints/create/Meadow-Endpoint-Create.js

@@ -0,0 +1,58 @@
+/**
+* Meadow Endpoint - Create a Record
+*/
+const doCreate = require('./Meadow-Operation-Create.js');
+
+const doAPIEndpointCreate = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Create');
+	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 create failure - a valid record is required.', 500));
+			}
+
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			doCreate.call(this, pRequest.body, pRequest, tmpRequestState, pResponse, fStageComplete);
+		},
+		(fStageComplete) =>
+		{
+			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];
+
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			pResponse.send(tmpRequestState.Record);
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Created a ${this.DAL.scope} record ID ${tmpRequestState.Record[this.DAL.defaultIdentifier]}`);
+			return fStageComplete();
+		}
+	],
+	(pError) =>
+	{
+		return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+	});
+};
+
+module.exports = doAPIEndpointCreate;

package/source/endpoints/create/Meadow-Operation-Create.js

@@ -0,0 +1,83 @@
+/**
+* Meadow Operation - Create a record function
+*/
+const doCreate = function(pRecord, pRequest, pRequestState, pResponse, fCallback)
+{
+	// This is a virtual operation
+	let tmpRequestState = this.cloneAsyncSafeRequestState(pRequestState, 'doCreate');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	if (!Array.isArray(tmpRequestState.ParentRequestState.CreatedRecords))
+	{
+		tmpRequestState.ParentRequestState.CreatedRecords = [];
+	}
+
+	this.waterfall(
+	[
+		(fStageComplete) =>
+		{
+			tmpRequestState.RecordToCreate = pRecord;
+
+			//Make sure record gets created with a customerID
+			if (!tmpRequestState.RecordToCreate.hasOwnProperty('IDCustomer') && this.DAL.jsonSchema.properties.hasOwnProperty('IDCustomer'))
+			{
+				tmpRequestState.RecordToCreate.IDCustomer = tmpRequestState.SessionData.CustomerID || 0;
+			}
+
+			return fStageComplete();
+		},
+		(fStageComplete) => { this.BehaviorInjection.runBehavior(`Create-PreOperation`, this, pRequest, tmpRequestState, fStageComplete); },
+		(fStageComplete) =>
+		{
+			// Prepare create query
+			tmpRequestState.Query = this.DAL.query;
+			tmpRequestState.Query.setIDUser(tmpRequestState.SessionData.UserID);
+			tmpRequestState.Query.addRecord(tmpRequestState.RecordToCreate);
+			return fStageComplete();
+		},
+		(fStageComplete) => { this.BehaviorInjection.runBehavior(`Create-QueryConfiguration`, this, pRequest, tmpRequestState, fStageComplete); },
+		(fStageComplete) =>
+		{
+			// Do the actual create operation with the DAL
+			this.DAL.doCreate(tmpRequestState.Query,
+				(pError, pQuery, pReadQuery, pNewRecord) =>
+				{
+					if (pError)
+					{
+						return fStageComplete(pError);
+					}
+					if (!pNewRecord)
+					{
+						return fStageComplete(this.ErrorHandler.getError(`Error in DAL Create: No record returned from persistence engine.`, 500));
+					}
+
+					tmpRequestState.Record = pNewRecord;
+
+					return fStageComplete();
+				});
+		},
+		(fStageComplete) => { return this.BehaviorInjection.runBehavior(`Create-PostOperation`, this, pRequest, tmpRequestState, fStageComplete); },
+		(fStageComplete) =>
+		{
+			tmpRequestState.ParentRequestState.CreatedRecords.push(tmpRequestState.Record);
+			this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Created a record with ${this.DAL.defaultIdentifier} = ${tmpRequestState.Record[this.DAL.defaultIdentifier]}`);
+			return fStageComplete();
+		}
+	],
+	(pError) =>
+	{
+		if (pError)
+		{
+			tmpRequestState.RecordToCreate.Error = pError;
+
+			tmpRequestState.ParentRequestState.RecordCreateError = true;
+			tmpRequestState.ParentRequestState.RecordCreateErrorObject = pError;
+
+			tmpRequestState.ParentRequestState.CreatedRecords.push(tmpRequestState.RecordToCreate);
+		}
+
+		return fCallback();
+	});
+};
+
+module.exports = doCreate;

package/source/endpoints/delete/Meadow-Endpoint-Delete.js

@@ -0,0 +1,93 @@
+/**
+* Meadow Endpoint - Delete a Record
+*/
+const doAPIEndpointDelete = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Delete');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	tmpRequestState.IDRecord = 0;
+	tmpRequestState.RecordCount = { Count:0 };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				if (typeof(pRequest.params.IDRecord) === 'string')
+				{
+					tmpRequestState.IDRecord = pRequest.params.IDRecord;
+				}
+				else if (typeof(pRequest.body[this.DAL.defaultIdentifier]) === 'number')
+				{
+					tmpRequestState.IDRecord = pRequest.body[this.DAL.defaultIdentifier];
+				}
+				else if (typeof(pRequest.body[this.DAL.defaultIdentifier]) === 'string')
+				{
+					tmpRequestState.IDRecord = pRequest.body[this.DAL.defaultIdentifier];
+				}
+				// Although the Meadow delete behavior does allow multiple deletes, we require an identifier.
+				// If a developer wants bulk delete, it will require a custom endpoint.
+				if (tmpRequestState.IDRecord < 1)
+				{
+					return fStageComplete(this.ErrorHandler.getError('Record delete failure - a valid record ID is required in the passed-in record.', 500));
+				}
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				tmpRequestState.Query.addFilter(this.DAL.defaultIdentifier, tmpRequestState.IDRecord);
+				tmpRequestState.Query.setIDUser(tmpRequestState.SessionData.UserID);
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Delete-QueryConfiguration`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				// Load the record so we can do security checks on it
+				this.DAL.doRead(tmpRequestState.Query,
+					(pError, pQuery, pRecord) =>
+					{
+						if (!pRecord)
+						{
+							return fStageComplete(this.ErrorHandler.getError('Record not found.', 404));
+						}
+						tmpRequestState.Record = pRecord;
+						return fStageComplete();
+					});
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Delete-PreOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				// Do the delete
+				this.DAL.doDelete(tmpRequestState.Query,
+					(pError, pQuery, pCount) =>
+					{
+						// MySQL returns the number of rows deleted
+						tmpRequestState.RecordCount.Count = pCount;
+						return fStageComplete(pError);
+					});
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Delete-PostOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.RecordCount);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Deleted ${tmpRequestState.RecordCount.Count} ${this.DAL.scope} records with ID ${tmpRequestState.IDRecord}`);
+				return fStageComplete();
+			}
+		], (pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointDelete;

package/source/endpoints/delete/Meadow-Endpoint-Undelete.js

@@ -0,0 +1,108 @@
+/**
+* Meadow Endpoint - Undelete a Record
+*/
+const doAPIEndpointUndelete = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Undelete');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+		var tmpIDRecord = 0;
+	if (typeof(pRequest.params.IDRecord) === 'string')
+	{
+		tmpIDRecord = pRequest.params.IDRecord;
+	}
+	else if (typeof(pRequest.body[this.DAL.defaultIdentifier]) === 'number')
+	{
+		tmpIDRecord = pRequest.body[this.DAL.defaultIdentifier];
+	}
+	else if (typeof(pRequest.body[this.DAL.defaultIdentifier]) === 'string')
+	{
+		tmpIDRecord = pRequest.body[this.DAL.defaultIdentifier];
+	}
+	// Although the undelete request does allow multiple undeletes, we require an identifier.
+	// TODO: Decide if we want to keep this pattern similar to Delete, or, if we want to change it to allow bulk undeletes.
+	if (tmpIDRecord < 1)
+	{
+		return fStageComplete(this.ErrorHandler.getError('Record undelete failure - a valid record ID is required.', 500));
+	}
+
+	tmpRequestState.RecordCount = {Count:0};
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				// Validate that the schema has a deleted bit
+				var tmpSchema = this.DAL.schema;
+				var tmpHasDeletedBit = false;
+				for (let i = 0; i < tmpSchema.length; i++)
+				{
+					if (tmpSchema[i].Type == 'Deleted')
+					{
+						tmpHasDeletedBit = true;
+					}
+				}
+
+				if (!tmpHasDeletedBit)
+				{
+					return fStageComplete(this.ErrorHandler.getError('No undelete bit on record.', 500));
+				}
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				// Now see if the record, with this identifier, for this user, exists with the deleted bit set to 1
+				tmpRequestState.Query = this.DAL.query;
+				tmpRequestState.Query.addFilter(this.DAL.defaultIdentifier, tmpIDRecord);
+				tmpRequestState.Query.addFilter('Deleted', 1);
+				tmpRequestState.Query.setIDUser(tmpRequestState.SessionData.UserID);
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				// Load the record so we can do security checks on it
+				this.DAL.doRead(tmpRequestState.Query,
+					(pError, pQuery, pRecord) =>
+					{
+						if (!pRecord)
+						{
+							return fStageComplete(this.ErrorHandler.getError('Record not found.', 404));
+						}
+						tmpRequestState.Record = pRecord;
+						return fStageComplete();
+					});
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Undelete-PreOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				// Do the undelete
+				this.DAL.doUndelete(tmpRequestState.Query,
+					(pError, pQuery, pCount) =>
+					{
+						// MySQL returns the number of rows deleted
+						tmpRequestState.RecordCount = {Count:pCount};
+						return fStageComplete(pError);
+					});
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Undelete-PostOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.RecordCount);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, 'Undeleted '+tmpRequestState.RecordCount.Count+' records with ID '+tmpIDRecord+'.');
+				return fStageComplete();
+			}
+		], (pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointUndelete;

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

@@ -0,0 +1,72 @@
+/**
+* Meadow Endpoint - Read a Record
+*/
+const doAPIEndpointRead = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Read');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Read-PreOperation`),
+			(fStageComplete) =>
+			{
+				if (!pRequest.params.IDRecord && pRequest.params.GUIDRecord)
+				{
+					// We use a custom name for this (RequestDefaultIdentifier) in case there is a query with a dot in the default identifier.
+					tmpRequestState.RecordSearchCriteria = `${this.DAL.defaultGUIdentifier} = ${pRequest.params.GUIDRecord}`;
+					tmpRequestState.Query.addFilter(this.DAL.defaultGUIdentifier, pRequest.params.GUIDRecord, '=', 'AND', 'RequestDefaultIdentifier');
+				}
+				else if (pRequest.params.IDRecord)
+				{
+					// We use a custon name for this (RequestDefaultIdentifier) in case there is a query with a dot in the default identifier.
+					tmpRequestState.RecordSearchCriteria = `${this.DAL.defaultIdentifier} = ${pRequest.params.IDRecord}`;
+					tmpRequestState.Query.addFilter(this.DAL.defaultIdentifier, pRequest.params.IDRecord, '=', 'AND', 'RequestDefaultIdentifier');
+				}
+				else
+				{
+					return fStageComplete(this.ErrorHandler.getError('No ID Provided', 400));
+				}
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Read-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				try
+				{
+					this.DAL.doRead(tmpRequestState.Query, (pError, pQuery, pRecord) =>
+					{
+						if (!pRecord)
+						{
+							return fStageComplete(this.ErrorHandler.getError('Record not Found', 404));
+						}
+						tmpRequestState.Record = pRecord;
+						return fStageComplete();
+					});
+				}
+				catch (pQueryError)
+				{
+					return fStageComplete(pQueryError);
+				}
+			},
+			fBehaviorInjector(`Read-PostOperation`),
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.Record);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read Record Where ${tmpRequestState.RecordSearchCriteria}`);
+				return fStageComplete();
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointRead;

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

@@ -0,0 +1,92 @@
+/**
+* Meadow Endpoint - Read a list of Records with a specified set of columns, distinct by those columns.
+*/
+const marshalDistinctList = require('./Meadow-Marshal-DistinctList.js');
+
+const doAPIEndpointReadDistinct = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadDistinct');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	tmpRequestState.DistinctColumns;
+
+	this.waterfall(
+	[
+		(fStageComplete) =>
+		{
+			tmpRequestState.Query = this.DAL.query.setDistinct(true);
+
+			let tmpCap = false;
+			let 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);
+			}
+			if (typeof(pRequest.params.Columns) === 'string')
+			{
+				tmpRequestState.DistinctColumns = pRequest.params.Columns.split(',');
+				if (!tmpRequestState.DistinctColumns)
+				{
+					return fStageComplete({Code:400, Message:'Columns to distinct on must be provided.'});
+				}
+				tmpRequestState.Query.setDataElements(tmpRequestState.DistinctColumns);
+			}
+			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.ResultRecords = marshalDistinctList.call(this, tmpRequestState.Records, pRequest, tmpRequestState.DistinctColumns);
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			return this.doStreamRecordArray(pResponse, tmpRequestState.ResultRecords, fStageComplete);
+		},
+		(fStageComplete) =>
+		{
+			this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read a recordset distinct lite list with ${tmpRequestState.ResultRecords.length} results.`);
+			return fStageComplete();
+		}
+	],
+	(pError) =>
+	{
+		return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+	});
+};
+
+module.exports = doAPIEndpointReadDistinct;