meadow-integration 1.0.1 → 1.0.4

package/source/cli/commands/Meadow-Integration-Command-ObjectArrayToCSV.js

@@ -32,7 +32,7 @@ class CommandConvertComprehensionToArray extends libCommandLineCommand
 			const pPropertyPath = pAddressPrefix ? `${pAddressPrefix}.${pKey}` : pKey;
 			if (pValue && typeof pValue === 'object' && !Array.isArray(pValue))
 			{
-				Object.assign(tmpFlattenedObject, flatten(pValue, pPropertyPath));
+				Object.assign(tmpFlattenedObject, this.flattenObject(pValue, pPropertyPath));
 			}
 			else
 			{
@@ -117,6 +117,7 @@ class CommandConvertComprehensionToArray extends libCommandLineCommand
 		if (!this.fable.FilePersistence.existsSync(tmpRawInputFilePath))
 		{
 			this.fable.log.error(`File [${tmpRawInputFilePath}] does not exist.`);
+			return fCallback();
 		}
 
 		const tmpMappingOutcome = {};
@@ -132,10 +133,10 @@ class CommandConvertComprehensionToArray extends libCommandLineCommand
 					// Check for the entity
 					if ((typeof(tmpMappingOutcome.RawRecordSet) == 'object') && (tmpEntity in tmpMappingOutcome.RawRecordSet))
 					{
-						this.fable.log.info(`Entity [${tmpEntity} found in the raw recordset comprehension.`);
+						this.fable.log.info(`Entity [${tmpEntity}] found in the raw recordset comprehension.`);
 						if (!Array.isArray(tmpMappingOutcome.RawRecordSet[tmpEntity]))
 						{
-							let tmpErrorMessage = `Expected an Array at Entity location in comprehension; data type was: ${typeof(tmpMappingOutcome.RawRecordSet)}`;
+							let tmpErrorMessage = `Expected an Array at Entity location in comprehension; data type was: ${typeof(tmpMappingOutcome.RawRecordSet[tmpEntity])}`;
 							this.fable.log.error(tmpErrorMessage);
 							return fCallback();
 						}
@@ -146,18 +147,42 @@ class CommandConvertComprehensionToArray extends libCommandLineCommand
 						this.fable.log.info(`Raw recordset is an array.`);
 						tmpMappingOutcome.RecordArray = tmpMappingOutcome.RawRecordSet;
 					}
-
-					if (!tmpMappingOutcome.RecordArray || !Array.isArray(tmpMappingOutcome.RecordArray))
+				}
+				else
+				{
+					// No entity specified -- expect the file to be a plain JSON array
+					if (Array.isArray(tmpMappingOutcome.RawRecordSet))
 					{
-						this.fable.log.error(`Could not locate a valid record array in JSON file.`);
-						return fCallback();
+						this.fable.log.info(`Raw recordset is an array.`);
+						tmpMappingOutcome.RecordArray = tmpMappingOutcome.RawRecordSet;
 					}
-					if (tmpMappingOutcome.RecordArray.length < 1)
+					else if (typeof(tmpMappingOutcome.RawRecordSet) == 'object')
 					{
-						this.fable.log.error(`No records in the record array.`);
-						return fCallback();
+						// Auto-detect: if the object has a single key whose value is an object, treat it as a comprehension
+						let tmpKeys = Object.keys(tmpMappingOutcome.RawRecordSet);
+						if (tmpKeys.length === 1 && typeof(tmpMappingOutcome.RawRecordSet[tmpKeys[0]]) === 'object' && !Array.isArray(tmpMappingOutcome.RawRecordSet[tmpKeys[0]]))
+						{
+							this.fable.log.info(`Auto-detected entity [${tmpKeys[0]}] from comprehension; converting object values to array.`);
+							tmpMappingOutcome.RecordArray = Object.values(tmpMappingOutcome.RawRecordSet[tmpKeys[0]]);
+						}
+						else if (tmpKeys.length > 0)
+						{
+							this.fable.log.error(`Input file is an object with keys [${tmpKeys.join(', ')}] but no -e entity flag was provided.  Please specify which entity to export with -e.`);
+							return fCallback();
+						}
 					}
 				}
+
+				if (!tmpMappingOutcome.RecordArray || !Array.isArray(tmpMappingOutcome.RecordArray))
+				{
+					this.fable.log.error(`Could not locate a valid record array in JSON file.`);
+					return fCallback();
+				}
+				if (tmpMappingOutcome.RecordArray.length < 1)
+				{
+					this.fable.log.error(`No records in the record array.`);
+					return fCallback();
+				}
 			}
 			catch (pError)
 			{
@@ -166,28 +191,20 @@ class CommandConvertComprehensionToArray extends libCommandLineCommand
 			}
 		}
 
-		try
-		{
-			this.streamFlattenedJSONToCSV(tmpMappingOutcome.RecordArray, tmpRawOutputFilePath)
-				.then(
-					() =>
-					{
-						this.pict.log.info(`CSV file created successfully: ${tmpRawOutputFilePath}`);
-					})
-				.catch(
-					(pError) =>
-					{
-						this.pict.log.error(`Error generating or writing CSV:`, pError);
-					});
-		}
-		catch (pError)
-		{
-			this.pict.log.error(`Error processing file ${tmpRawInputFilePath}:`, pError);
-		}
-
-		this.fable.log.info(`CSV File written to [${tmpRawOutputFilePath}].`);
-		this.fable.log.info(`Have a nice day!`);
-		return fCallback();
+		this.streamFlattenedJSONToCSV(tmpMappingOutcome.RecordArray, tmpRawOutputFilePath)
+			.then(
+				() =>
+				{
+					this.fable.log.info(`CSV file created successfully: ${tmpRawOutputFilePath}`);
+					this.fable.log.info(`Have a nice day!`);
+					return fCallback();
+				})
+			.catch(
+				(pError) =>
+				{
+					this.fable.log.error(`Error generating or writing CSV:`, pError);
+					return fCallback();
+				});
 	};
 }
 

package/source/cli/commands/Meadow-Integration-Command-Serve.js

@@ -0,0 +1,51 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+const MeadowIntegrationServer = require('../../restserver/Meadow-Integration-Server.js');
+
+class MeadowIntegrationCommandServe extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'serve';
+		this.options.Description = 'Start the Meadow Integration REST API server.';
+		this.options.Aliases.push('server');
+		this.options.Aliases.push('rest');
+
+		this.options.CommandOptions.push({ Name: '-p, --port [port]', Description: 'The port to listen on.  Defaults to 8086.', Default: '8086' });
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		let tmpPort = parseInt(this.CommandOptions.port, 10) || 8086;
+
+		// Also respect the environment variable
+		if (process.env.MEADOW_INTEGRATION_PORT)
+		{
+			tmpPort = parseInt(process.env.MEADOW_INTEGRATION_PORT, 10) || tmpPort;
+		}
+
+		this.log.info(`Starting Meadow Integration REST server on port ${tmpPort}...`);
+
+		let tmpServer = new MeadowIntegrationServer(
+			{
+				APIServerPort: tmpPort
+			});
+
+		tmpServer.start(
+			(pError) =>
+			{
+				if (pError)
+				{
+					this.log.error(`Failed to start server: ${pError}`, pError);
+					return fCallback(pError);
+				}
+				// Server is running; don't call fCallback so the process stays alive.
+			});
+	}
+}
+
+module.exports = MeadowIntegrationCommandServe;

package/source/restserver/Meadow-Integration-Server-Endpoints.js

@@ -0,0 +1,83 @@
+/**
+ * Meadow Integration Server - Endpoint Registration
+ *
+ * Registers all REST API endpoints with the Orator service server.
+ *
+ * Endpoint Summary:
+ *
+ * --- Status ---
+ * GET  /1.0/Status                             Server status and available endpoints
+ *
+ * --- CSV Operations ---
+ * POST /1.0/CSV/Check                          Analyze a CSV file for statistics
+ * POST /1.0/CSV/Transform                      Transform a CSV file into a comprehension
+ *
+ * --- TSV Operations ---
+ * POST /1.0/TSV/Check                          Analyze a TSV file for statistics
+ * POST /1.0/TSV/Transform                      Transform a TSV file into a comprehension
+ *
+ * --- JSON Array Operations ---
+ * POST /1.0/JSONArray/Transform                Transform a JSON Array file into a comprehension
+ * POST /1.0/JSONArray/TransformRecords         Transform an in-memory JSON array into a comprehension
+ *
+ * --- Comprehension Operations ---
+ * POST /1.0/Comprehension/Intersect            Merge two comprehension objects (in-memory)
+ * POST /1.0/Comprehension/IntersectFiles       Merge two comprehension files
+ * POST /1.0/Comprehension/ToArray              Convert comprehension to array (in-memory)
+ * POST /1.0/Comprehension/ToArrayFromFile      Convert comprehension file to array
+ * POST /1.0/Comprehension/ToCSV               Convert comprehension/array to CSV (in-memory)
+ * POST /1.0/Comprehension/ToCSVFromFile        Convert comprehension/array file to CSV
+ * POST /1.0/Comprehension/Push                 Push comprehension to Meadow REST APIs (in-memory)
+ * POST /1.0/Comprehension/PushFile             Push comprehension file to Meadow REST APIs
+ *
+ * --- Entity Generation ---
+ * POST /1.0/Entity/FromTabularFolder           Generate comprehensions from a folder of tabular files
+ */
+
+module.exports.connectRoutes = function(pFable, pOrator)
+{
+	// Status endpoint
+	pOrator.serviceServer.get('/1.0/Status',
+		(pRequest, pResponse, fNext) =>
+		{
+			pResponse.send(200,
+				{
+					Product: pFable.settings.Product,
+					Version: pFable.settings.ProductVersion || require('../../package.json').version,
+					Status: 'Running',
+					Endpoints:
+						[
+							'POST /1.0/CSV/Check',
+							'POST /1.0/CSV/Transform',
+							'POST /1.0/TSV/Check',
+							'POST /1.0/TSV/Transform',
+							'POST /1.0/JSONArray/Transform',
+							'POST /1.0/JSONArray/TransformRecords',
+							'POST /1.0/Comprehension/Intersect',
+							'POST /1.0/Comprehension/IntersectFiles',
+							'POST /1.0/Comprehension/ToArray',
+							'POST /1.0/Comprehension/ToArrayFromFile',
+							'POST /1.0/Comprehension/ToCSV',
+							'POST /1.0/Comprehension/ToCSVFromFile',
+							'POST /1.0/Comprehension/Push',
+							'POST /1.0/Comprehension/PushFile',
+							'POST /1.0/Entity/FromTabularFolder'
+						]
+				});
+			return fNext();
+		});
+
+	// Register all endpoint handlers
+	require('./endpoints/Endpoint-CSVCheck.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-CSVTransform.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-TSVCheck.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-TSVTransform.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-JSONArrayTransform.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-ComprehensionIntersect.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-ComprehensionArray.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-ObjectArrayToCSV.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-ComprehensionPush.js')(pFable, pOrator);
+	require('./endpoints/Endpoint-EntityFromTabularFolder.js')(pFable, pOrator);
+
+	pFable.log.info(`Meadow Integration Server: ${15} REST endpoints registered.`);
+};

package/source/restserver/Meadow-Integration-Server.js

@@ -0,0 +1,86 @@
+const libPict = require('pict');
+const libOrator = require('orator');
+const libOratorServiceServerRestify = require('orator-serviceserver-restify');
+
+const libEndpoints = require('./Meadow-Integration-Server-Endpoints.js');
+
+class MeadowIntegrationServer
+{
+	constructor(pSettings)
+	{
+		let tmpSettings = Object.assign(
+			{
+				Product: 'Meadow-Integration-Server',
+				ProductVersion: require('../../package.json').version,
+
+				APIServerPort: 8086,
+
+				// The default working directory for file operations
+				WorkingDirectory: process.cwd()
+			}, pSettings);
+
+		this._Settings = tmpSettings;
+
+		// Use Pict instead of Fable so parseTemplate and ExpressionParser are available
+		this._Fable = new libPict(tmpSettings);
+
+		// Register the Restify service server type
+		this._Fable.serviceManager.addServiceType('OratorServiceServer', libOratorServiceServerRestify);
+
+		// Create the Orator service
+		this._Orator = new libOrator(this._Fable, {});
+
+		// Initialize core fable services that the endpoints rely on
+		this._Fable.instantiateServiceProvider('CSVParser');
+		this._Fable.instantiateServiceProvider('FilePersistence');
+		this._Fable.instantiateServiceProvider('DataGeneration');
+	}
+
+	start(fCallback)
+	{
+		let tmpCallback = (typeof(fCallback) === 'function') ? fCallback : () => {};
+
+		this._Orator.initialize(
+			(pError) =>
+			{
+				if (pError)
+				{
+					this._Fable.log.error(`Error initializing Orator: ${pError}`, pError);
+					return tmpCallback(pError);
+				}
+
+				// Register all endpoints
+				libEndpoints.connectRoutes(this._Fable, this._Orator);
+
+				this._Orator.startService(
+					(pStartError) =>
+					{
+						if (pStartError)
+						{
+							this._Fable.log.error(`Error starting Orator service: ${pStartError}`, pStartError);
+							return tmpCallback(pStartError);
+						}
+
+						this._Fable.log.info(`Meadow Integration Server running on port ${this._Settings.APIServerPort}`);
+						return tmpCallback();
+					});
+			});
+	}
+
+	stop(fCallback)
+	{
+		let tmpCallback = (typeof(fCallback) === 'function') ? fCallback : () => {};
+
+		this._Orator.stopService(
+			(pError) =>
+			{
+				if (pError)
+				{
+					this._Fable.log.error(`Error stopping Orator service: ${pError}`, pError);
+				}
+				return tmpCallback(pError);
+			});
+	}
+}
+
+module.exports = MeadowIntegrationServer;

package/source/restserver/endpoints/Endpoint-CSVCheck.js

@@ -0,0 +1,91 @@
+const libFS = require('fs');
+const libPath = require('path');
+const libReadline = require('readline');
+
+/**
+ * POST /1.0/CSV/Check
+ *
+ * Analyze a CSV file for statistics.
+ *
+ * Request body (JSON):
+ * {
+ *   "File": "/absolute/path/to/file.csv",     // The CSV file to analyze
+ *   "Records": false,                          // (optional) Include full record dump
+ *   "QuoteDelimiter": "\""                     // (optional) Quote delimiter character
+ * }
+ *
+ * Response: JSON statistics object
+ */
+module.exports = function(pFable, pOrator)
+{
+	pOrator.serviceServer.postWithBodyParser('/1.0/CSV/Check',
+		(pRequest, pResponse, fNext) =>
+		{
+			let tmpBody = pRequest.body || {};
+
+			if (!tmpBody.File || (typeof(tmpBody.File) !== 'string'))
+			{
+				pResponse.send(400, { Error: 'No valid File path provided in request body.' });
+				return fNext();
+			}
+
+			pFable.instantiateServiceProvider('FilePersistence');
+			pFable.addAndInstantiateServiceTypeIfNotExists('MeadowIntegrationTabularCheck', require('../../services/tabular/Service-TabularCheck.js'));
+
+			let tmpInputFilePath = pFable.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!pFable.FilePersistence.existsSync(tmpInputFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpInputFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			// Create a fresh CSVParser for each request to reset header state
+			let tmpCSVParser = pFable.instantiateServiceProviderWithoutRegistration('CSVParser');
+
+			if (tmpBody.QuoteDelimiter)
+			{
+				tmpCSVParser.QuoteCharacter = tmpBody.QuoteDelimiter;
+			}
+
+			let tmpStatistics = pFable.MeadowIntegrationTabularCheck.newStatisticsObject(tmpInputFilePath);
+			let tmpStoreFullRecord = (tmpBody.Records === true);
+
+			if (tmpStoreFullRecord)
+			{
+				tmpStatistics.Records = [];
+			}
+
+			const tmpReadline = libReadline.createInterface(
+				{
+					input: libFS.createReadStream(tmpInputFilePath),
+					crlfDelay: Infinity,
+				});
+
+			tmpReadline.on('line',
+				(pLine) =>
+				{
+					const tmpRecord = tmpCSVParser.parseCSVLine(pLine);
+					if (tmpRecord)
+					{
+						pFable.MeadowIntegrationTabularCheck.collectStatistics(tmpRecord, tmpStatistics, tmpStoreFullRecord);
+					}
+				});
+
+			tmpReadline.on('close',
+				() =>
+				{
+					pFable.log.info(`CSV Check: ${tmpStatistics.RowCount} rows, ${tmpStatistics.ColumnCount} columns in [${tmpInputFilePath}].`);
+					pResponse.send(200, tmpStatistics);
+					return fNext();
+				});
+
+			tmpReadline.on('error',
+				(pError) =>
+				{
+					pFable.log.error(`CSV Check error reading file [${tmpInputFilePath}]: ${pError}`, pError);
+					pResponse.send(500, { Error: `Error reading CSV file: ${pError.message}` });
+					return fNext();
+				});
+		});
+};

package/source/restserver/endpoints/Endpoint-CSVTransform.js

@@ -0,0 +1,189 @@
+const libFS = require('fs');
+const libPath = require('path');
+const libReadline = require('readline');
+
+/**
+ * POST /1.0/CSV/Transform
+ *
+ * Transform a CSV file into a comprehension.
+ *
+ * Request body (JSON):
+ * {
+ *   "File": "/absolute/path/to/file.csv",            // The CSV file to transform
+ *   "Entity": "MyEntity",                             // (optional) Entity name
+ *   "GUIDName": "GUIDMyEntity",                       // (optional) GUID column name
+ *   "GUIDTemplate": "{~D:Record.id~}",                // (optional) Pict template for GUID
+ *   "Mappings": { "Col1": "{~D:Record.col1~}" },      // (optional) Column mappings object
+ *   "MappingConfiguration": { ... },                  // (optional) Full explicit mapping config
+ *   "IncomingComprehension": { ... },                 // (optional) Existing comprehension to merge into
+ *   "Extended": false,                                // (optional) Return full operation state
+ *   "QuoteDelimiter": "\""                            // (optional) Quote delimiter character
+ * }
+ *
+ * Response: Comprehension JSON (or extended state if Extended=true)
+ */
+module.exports = function(pFable, pOrator)
+{
+	pOrator.serviceServer.postWithBodyParser('/1.0/CSV/Transform',
+		(pRequest, pResponse, fNext) =>
+		{
+			let tmpBody = pRequest.body || {};
+
+			if (!tmpBody.File || (typeof(tmpBody.File) !== 'string'))
+			{
+				pResponse.send(400, { Error: 'No valid File path provided in request body.' });
+				return fNext();
+			}
+
+			pFable.instantiateServiceProvider('FilePersistence');
+			pFable.addAndInstantiateServiceTypeIfNotExists('MeadowIntegrationTabularTransform', require('../../services/tabular/Service-TabularTransform.js'));
+
+			let tmpInputFilePath = pFable.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!pFable.FilePersistence.existsSync(tmpInputFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpInputFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			// Create a fresh CSVParser for each request to reset header state
+			let tmpCSVParser = pFable.instantiateServiceProviderWithoutRegistration('CSVParser');
+
+			if (tmpBody.QuoteDelimiter)
+			{
+				tmpCSVParser.QuoteCharacter = tmpBody.QuoteDelimiter;
+			}
+
+			let tmpMappingOutcome = pFable.MeadowIntegrationTabularTransform.newMappingOutcomeObject();
+
+			// Apply user configuration from request body
+			if (tmpBody.Entity)
+			{
+				tmpMappingOutcome.UserConfiguration.Entity = tmpBody.Entity;
+			}
+			if (tmpBody.GUIDName)
+			{
+				tmpMappingOutcome.UserConfiguration.GUIDName = tmpBody.GUIDName;
+			}
+			if (tmpBody.GUIDTemplate)
+			{
+				tmpMappingOutcome.UserConfiguration.GUIDTemplate = tmpBody.GUIDTemplate;
+			}
+			if (tmpBody.Mappings && (typeof(tmpBody.Mappings) === 'object'))
+			{
+				tmpMappingOutcome.UserConfiguration.Mappings = tmpBody.Mappings;
+			}
+
+			// Apply explicit mapping configuration
+			if (tmpBody.MappingConfiguration && (typeof(tmpBody.MappingConfiguration) === 'object'))
+			{
+				tmpMappingOutcome.ExplicitConfiguration = tmpBody.MappingConfiguration;
+			}
+
+			// Apply incoming comprehension
+			if (tmpBody.IncomingComprehension && (typeof(tmpBody.IncomingComprehension) === 'object'))
+			{
+				tmpMappingOutcome.ExistingComprehension = tmpBody.IncomingComprehension;
+				tmpMappingOutcome.Comprehension = JSON.parse(JSON.stringify(tmpBody.IncomingComprehension));
+			}
+
+			const tmpReadline = libReadline.createInterface(
+				{
+					input: libFS.createReadStream(tmpInputFilePath),
+					crlfDelay: Infinity,
+				});
+
+			tmpReadline.on('line',
+				(pLine) =>
+				{
+					const tmpIncomingRecord = tmpCSVParser.parseCSVLine(pLine);
+					tmpMappingOutcome.ParsedRowCount++;
+
+					if (tmpIncomingRecord)
+					{
+						if (!tmpMappingOutcome.ImplicitConfiguration)
+						{
+							tmpMappingOutcome.ImplicitConfiguration = pFable.MeadowIntegrationTabularTransform.generateMappingConfigurationPrototype(libPath.basename(tmpInputFilePath), tmpIncomingRecord);
+
+							if ((!tmpMappingOutcome.ExplicitConfiguration) || (typeof(tmpMappingOutcome.ExplicitConfiguration) != 'object'))
+							{
+								tmpMappingOutcome.Configuration = Object.assign({}, tmpMappingOutcome.ImplicitConfiguration, tmpMappingOutcome.UserConfiguration);
+							}
+							else
+							{
+								tmpMappingOutcome.Configuration = Object.assign({}, tmpMappingOutcome.ImplicitConfiguration, tmpMappingOutcome.ExplicitConfiguration, tmpMappingOutcome.UserConfiguration);
+							}
+
+							if (!('GUIDName' in tmpMappingOutcome.Configuration))
+							{
+								tmpMappingOutcome.Configuration.GUIDName = `GUID${tmpMappingOutcome.Configuration.Entity}`;
+							}
+
+							if (!(tmpMappingOutcome.Configuration.Entity in tmpMappingOutcome.Comprehension))
+							{
+								tmpMappingOutcome.Comprehension[tmpMappingOutcome.Configuration.Entity] = {};
+							}
+						}
+
+						let tmpMappingRecordSolution = (
+							{
+								IncomingRecord: tmpIncomingRecord,
+								MappingConfiguration: tmpMappingOutcome.Configuration,
+								MappingOutcome: tmpMappingOutcome,
+								RowIndex: tmpMappingOutcome.ParsedRowCount,
+								NewRecordsGUIDUniqueness: [],
+								NewRecordPrototype: {},
+								Fable: pFable,
+								Pict: pFable,
+								AppData: pFable.AppData
+							});
+
+						// Run the solvers for this record
+						let tmpSolverResultsObject = {};
+						if (tmpMappingOutcome.Configuration.Solvers && Array.isArray(tmpMappingOutcome.Configuration.Solvers))
+						{
+							for (let i = 0; i < tmpMappingOutcome.Configuration.Solvers.length; i++)
+							{
+								let tmpSolver = tmpMappingOutcome.Configuration.Solvers[i];
+								pFable.ExpressionParser.solve(tmpSolver, tmpMappingRecordSolution, tmpSolverResultsObject, pFable.manifest, tmpMappingRecordSolution);
+							}
+						}
+
+						if (tmpMappingOutcome.Configuration.MultipleGUIDUniqueness && tmpMappingRecordSolution.NewRecordsGUIDUniqueness.length > 0)
+						{
+							for (let i = 0; i < tmpMappingRecordSolution.NewRecordsGUIDUniqueness.length; i++)
+							{
+								pFable.MeadowIntegrationTabularTransform.addRecordToComprehension(tmpIncomingRecord, tmpMappingOutcome, tmpMappingRecordSolution.NewRecordPrototype, tmpMappingRecordSolution.NewRecordsGUIDUniqueness[i]);
+							}
+						}
+						else if (!tmpMappingOutcome.Configuration.MultipleGUIDUniqueness)
+						{
+							pFable.MeadowIntegrationTabularTransform.addRecordToComprehension(tmpIncomingRecord, tmpMappingOutcome, tmpMappingRecordSolution.NewRecordPrototype);
+						}
+					}
+				});
+
+			tmpReadline.on('close',
+				() =>
+				{
+					pFable.log.info(`CSV Transform: Parsed ${tmpMappingOutcome.ParsedRowCount} rows from [${tmpInputFilePath}].`);
+					if (tmpBody.Extended)
+					{
+						pResponse.send(200, tmpMappingOutcome);
+					}
+					else
+					{
+						pResponse.send(200, tmpMappingOutcome.Comprehension);
+					}
+					return fNext();
+				});
+
+			tmpReadline.on('error',
+				(pError) =>
+				{
+					pFable.log.error(`CSV Transform error reading file [${tmpInputFilePath}]: ${pError}`, pError);
+					pResponse.send(500, { Error: `Error reading CSV file: ${pError.message}` });
+					return fNext();
+				});
+		});
+};