retold-data-service 2.0.13 → 2.0.14

package/source/services/meadow-integration/MeadowIntegration-Command-EntityFromTabularFolder.js

@@ -0,0 +1,244 @@
+/**
+ * MeadowIntegration Command - Entity From Tabular Folder
+ *
+ * POST /1.0/Retold/MeadowIntegration/Entity/FromTabularFolder
+ *
+ * Generate entity comprehensions from tabular data files in a folder.
+ * Supports CSV, TSV, and JSON array files.
+ *
+ * Body: { "Folder": "/path/to/folder/", "Entity": "ForcedEntity", "MappingConfiguration": {...} }
+ * Returns: Comprehension JSON from all tabular files in the folder
+ */
+const libFS = require('fs');
+const libPath = require('path');
+
+module.exports = function(pIntegrationService, pOratorServiceServer)
+{
+	let tmpPict = pIntegrationService.pict;
+
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Entity/FromTabularFolder`,
+		(pRequest, pResponse, fNext) =>
+		{
+			let tmpBody = pRequest.body || {};
+
+			if (!tmpBody.Folder || (typeof(tmpBody.Folder) !== 'string'))
+			{
+				pResponse.send(400, { Error: 'No valid Folder path provided in request body.' });
+				return fNext();
+			}
+
+			let tmpFolderPath = tmpPict.FilePersistence.resolvePath(tmpBody.Folder);
+
+			if (!libFS.existsSync(tmpFolderPath))
+			{
+				pResponse.send(404, { Error: `Folder [${tmpFolderPath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpStat = libFS.statSync(tmpFolderPath);
+			if (!tmpStat.isDirectory())
+			{
+				pResponse.send(400, { Error: `Path [${tmpFolderPath}] is not a directory.` });
+				return fNext();
+			}
+
+			let tmpFiles;
+			try
+			{
+				tmpFiles = libFS.readdirSync(tmpFolderPath);
+			}
+			catch (pError)
+			{
+				pResponse.send(500, { Error: `Error reading folder [${tmpFolderPath}]: ${pError.message}` });
+				return fNext();
+			}
+
+			let tmpTabularFiles = tmpFiles.filter(
+				(pFile) =>
+				{
+					let tmpExt = libPath.extname(pFile).toLowerCase();
+					return (tmpExt === '.csv' || tmpExt === '.tsv' || tmpExt === '.json');
+				});
+
+			if (tmpTabularFiles.length < 1)
+			{
+				pResponse.send(400, { Error: `No tabular files (CSV, TSV, JSON) found in folder [${tmpFolderPath}].` });
+				return fNext();
+			}
+
+			let tmpComprehension = {};
+			let tmpAnticipate = tmpPict.newAnticipate();
+
+			for (let f = 0; f < tmpTabularFiles.length; f++)
+			{
+				let tmpFileName = tmpTabularFiles[f];
+				let tmpFilePath = libPath.join(tmpFolderPath, tmpFileName);
+				let tmpExt = libPath.extname(tmpFileName).toLowerCase();
+
+				tmpAnticipate.anticipate(
+					(function(pFilePath, pFileName, pExt)
+					{
+						return function(fDone)
+						{
+							processTabularFile(tmpPict, pFilePath, pFileName, pExt, tmpBody, tmpComprehension, fDone);
+						};
+					})(tmpFilePath, tmpFileName, tmpExt));
+			}
+
+			tmpAnticipate.wait(
+				(pError) =>
+				{
+					if (pError)
+					{
+						tmpPict.log.error(`Error processing tabular folder: ${pError}`, pError);
+						pResponse.send(500, { Error: `Error processing tabular folder: ${pError.message || pError}` });
+						return fNext();
+					}
+
+					let tmpEntityCount = Object.keys(tmpComprehension).length;
+					tmpPict.log.info(`Entity From Tabular Folder: Generated comprehension with ${tmpEntityCount} entity(ies) from ${tmpTabularFiles.length} file(s).`);
+					pResponse.send(200, tmpComprehension);
+					return fNext();
+				});
+		});
+};
+
+function processTabularFile(pPict, pFilePath, pFileName, pExt, pOptions, pComprehension, fCallback)
+{
+	let tmpMappingOutcome = pPict.MeadowIntegrationTabularTransform.newMappingOutcomeObject();
+
+	if (pOptions.Entity)
+	{
+		tmpMappingOutcome.UserConfiguration.Entity = pOptions.Entity;
+	}
+	if (pOptions.MappingConfiguration && (typeof(pOptions.MappingConfiguration) === 'object'))
+	{
+		tmpMappingOutcome.ExplicitConfiguration = pOptions.MappingConfiguration;
+	}
+
+	if (pExt === '.json')
+	{
+		let tmpRawContents;
+		try
+		{
+			tmpRawContents = pPict.FilePersistence.readFileSync(pFilePath, { encoding: 'utf8' });
+			let tmpRecords = JSON.parse(tmpRawContents);
+			if (!Array.isArray(tmpRecords))
+			{
+				pPict.log.warn(`File [${pFileName}] is not a JSON array. Skipping.`);
+				return fCallback();
+			}
+
+			for (let i = 0; i < tmpRecords.length; i++)
+			{
+				let tmpIncomingRecord = tmpRecords[i];
+				tmpMappingOutcome.ParsedRowCount++;
+
+				if (tmpIncomingRecord)
+				{
+					if (!tmpMappingOutcome.ImplicitConfiguration)
+					{
+						tmpMappingOutcome.ImplicitConfiguration = pPict.MeadowIntegrationTabularTransform.generateMappingConfigurationPrototype(libPath.basename(pFileName, pExt), tmpIncomingRecord);
+						mergeConfiguration(tmpMappingOutcome);
+					}
+					pPict.MeadowIntegrationTabularTransform.addRecordToComprehension(tmpIncomingRecord, tmpMappingOutcome);
+				}
+			}
+
+			mergeIntoMainComprehension(pComprehension, tmpMappingOutcome.Comprehension);
+			return fCallback();
+		}
+		catch (pError)
+		{
+			pPict.log.error(`Error parsing JSON file [${pFileName}]: ${pError.message}`);
+			return fCallback();
+		}
+	}
+	else
+	{
+		let tmpCSVParser = pPict.instantiateServiceProviderWithoutRegistration('CSVParser');
+
+		if (pExt === '.tsv')
+		{
+			tmpCSVParser.Delimiter = '\t';
+		}
+		else
+		{
+			tmpCSVParser.Delimiter = ',';
+		}
+
+		const libReadline = require('readline');
+		const tmpReadline = libReadline.createInterface(
+			{
+				input: libFS.createReadStream(pFilePath),
+				crlfDelay: Infinity,
+			});
+
+		tmpReadline.on('line',
+			(pLine) =>
+			{
+				const tmpIncomingRecord = tmpCSVParser.parseCSVLine(pLine);
+				tmpMappingOutcome.ParsedRowCount++;
+
+				if (tmpIncomingRecord)
+				{
+					if (!tmpMappingOutcome.ImplicitConfiguration)
+					{
+						tmpMappingOutcome.ImplicitConfiguration = pPict.MeadowIntegrationTabularTransform.generateMappingConfigurationPrototype(libPath.basename(pFileName, pExt), tmpIncomingRecord);
+						mergeConfiguration(tmpMappingOutcome);
+					}
+					pPict.MeadowIntegrationTabularTransform.addRecordToComprehension(tmpIncomingRecord, tmpMappingOutcome);
+				}
+			});
+
+		tmpReadline.on('close',
+			() =>
+			{
+				mergeIntoMainComprehension(pComprehension, tmpMappingOutcome.Comprehension);
+				return fCallback();
+			});
+
+		tmpReadline.on('error',
+			(pError) =>
+			{
+				pPict.log.error(`Error reading file [${pFileName}]: ${pError.message}`);
+				return fCallback();
+			});
+	}
+}
+
+function mergeConfiguration(pMappingOutcome)
+{
+	if ((!pMappingOutcome.ExplicitConfiguration) || (typeof(pMappingOutcome.ExplicitConfiguration) != 'object'))
+	{
+		pMappingOutcome.Configuration = Object.assign({}, pMappingOutcome.ImplicitConfiguration, pMappingOutcome.UserConfiguration);
+	}
+	else
+	{
+		pMappingOutcome.Configuration = Object.assign({}, pMappingOutcome.ImplicitConfiguration, pMappingOutcome.ExplicitConfiguration, pMappingOutcome.UserConfiguration);
+	}
+
+	if (!('GUIDName' in pMappingOutcome.Configuration))
+	{
+		pMappingOutcome.Configuration.GUIDName = `GUID${pMappingOutcome.Configuration.Entity}`;
+	}
+
+	if (!(pMappingOutcome.Configuration.Entity in pMappingOutcome.Comprehension))
+	{
+		pMappingOutcome.Comprehension[pMappingOutcome.Configuration.Entity] = {};
+	}
+}
+
+function mergeIntoMainComprehension(pMainComprehension, pFileComprehension)
+{
+	let tmpEntities = Object.keys(pFileComprehension);
+	for (let i = 0; i < tmpEntities.length; i++)
+	{
+		let tmpEntity = tmpEntities[i];
+		if (!pMainComprehension[tmpEntity])
+		{
+			pMainComprehension[tmpEntity] = {};
+		}
+		Object.assign(pMainComprehension[tmpEntity], pFileComprehension[tmpEntity]);
+	}
+}

package/source/services/meadow-integration/MeadowIntegration-Command-JSONArrayTransform.js

@@ -0,0 +1,213 @@
+/**
+ * MeadowIntegration Command - JSON Array Transform
+ *
+ * POST /1.0/Retold/MeadowIntegration/JSONArray/Transform
+ *   Transform a JSON Array file into a comprehension.
+ *
+ * POST /1.0/Retold/MeadowIntegration/JSONArray/TransformRecords
+ *   Transform an in-memory JSON array into a comprehension (no file needed).
+ *
+ * Body (file-based): { "File": "/path/to/array.json", ...mapping options... }
+ * Body (in-memory):  { "Records": [{...}, ...], ...mapping options... }
+ * Returns: Comprehension JSON (or extended state if Extended=true)
+ */
+const libPath = require('path');
+
+module.exports = function(pIntegrationService, pOratorServiceServer)
+{
+	let tmpPict = pIntegrationService.pict;
+
+	// File-based transform
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/JSONArray/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();
+			}
+
+			let tmpInputFilePath = tmpPict.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!tmpPict.FilePersistence.existsSync(tmpInputFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpInputFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpJSONArrayRecords;
+			try
+			{
+				let tmpRawContents = tmpPict.FilePersistence.readFileSync(tmpInputFilePath, { encoding: 'utf8' });
+				tmpJSONArrayRecords = JSON.parse(tmpRawContents);
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing JSON file [${tmpInputFilePath}]: ${pError.message}` });
+				return fNext();
+			}
+
+			if (!Array.isArray(tmpJSONArrayRecords))
+			{
+				pResponse.send(400, { Error: `File [${tmpInputFilePath}] does not contain a valid JSON array.` });
+				return fNext();
+			}
+
+			let tmpResult = processJSONArrayTransform(tmpPict, tmpBody, tmpJSONArrayRecords, libPath.basename(tmpInputFilePath));
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			if (tmpBody.Extended)
+			{
+				pResponse.send(200, tmpResult.MappingOutcome);
+			}
+			else
+			{
+				pResponse.send(200, tmpResult.MappingOutcome.Comprehension);
+			}
+			return fNext();
+		});
+
+	// In-memory records transform
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/JSONArray/TransformRecords`,
+		(pRequest, pResponse, fNext) =>
+		{
+			let tmpBody = pRequest.body || {};
+
+			if (!tmpBody.Records || !Array.isArray(tmpBody.Records))
+			{
+				pResponse.send(400, { Error: 'No valid Records array provided in request body.' });
+				return fNext();
+			}
+
+			if (tmpBody.Records.length < 1)
+			{
+				pResponse.send(400, { Error: 'Records array is empty.' });
+				return fNext();
+			}
+
+			let tmpDatasetName = tmpBody.Entity || 'Records';
+			let tmpResult = processJSONArrayTransform(tmpPict, tmpBody, tmpBody.Records, tmpDatasetName);
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			if (tmpBody.Extended)
+			{
+				pResponse.send(200, tmpResult.MappingOutcome);
+			}
+			else
+			{
+				pResponse.send(200, tmpResult.MappingOutcome.Comprehension);
+			}
+			return fNext();
+		});
+};
+
+function processJSONArrayTransform(pPict, pOptions, pRecords, pDatasetName)
+{
+	let tmpMappingOutcome = pPict.MeadowIntegrationTabularTransform.newMappingOutcomeObject();
+
+	if (pOptions.Entity)
+	{
+		tmpMappingOutcome.UserConfiguration.Entity = pOptions.Entity;
+	}
+	if (pOptions.GUIDName)
+	{
+		tmpMappingOutcome.UserConfiguration.GUIDName = pOptions.GUIDName;
+	}
+	if (pOptions.GUIDTemplate)
+	{
+		tmpMappingOutcome.UserConfiguration.GUIDTemplate = pOptions.GUIDTemplate;
+	}
+	if (pOptions.Mappings && (typeof(pOptions.Mappings) === 'object'))
+	{
+		tmpMappingOutcome.UserConfiguration.Mappings = pOptions.Mappings;
+	}
+	if (pOptions.MappingConfiguration && (typeof(pOptions.MappingConfiguration) === 'object'))
+	{
+		tmpMappingOutcome.ExplicitConfiguration = pOptions.MappingConfiguration;
+	}
+	if (pOptions.IncomingComprehension && (typeof(pOptions.IncomingComprehension) === 'object'))
+	{
+		tmpMappingOutcome.ExistingComprehension = pOptions.IncomingComprehension;
+		tmpMappingOutcome.Comprehension = JSON.parse(JSON.stringify(pOptions.IncomingComprehension));
+	}
+
+	for (let i = 0; i < pRecords.length; i++)
+	{
+		const tmpIncomingRecord = pRecords[i];
+		tmpMappingOutcome.ParsedRowCount++;
+
+		if (tmpIncomingRecord)
+		{
+			if (!tmpMappingOutcome.ImplicitConfiguration)
+			{
+				tmpMappingOutcome.ImplicitConfiguration = pPict.MeadowIntegrationTabularTransform.generateMappingConfigurationPrototype(pDatasetName, 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: pPict,
+					Pict: pPict,
+					AppData: pPict.AppData
+				});
+
+			let tmpSolverResultsObject = {};
+			if (tmpMappingOutcome.Configuration.Solvers && Array.isArray(tmpMappingOutcome.Configuration.Solvers))
+			{
+				for (let j = 0; j < tmpMappingOutcome.Configuration.Solvers.length; j++)
+				{
+					pPict.ExpressionParser.solve(tmpMappingOutcome.Configuration.Solvers[j], tmpMappingRecordSolution, tmpSolverResultsObject, pPict.manifest, tmpMappingRecordSolution);
+				}
+			}
+
+			if (tmpMappingOutcome.Configuration.MultipleGUIDUniqueness && tmpMappingRecordSolution.NewRecordsGUIDUniqueness.length > 0)
+			{
+				for (let j = 0; j < tmpMappingRecordSolution.NewRecordsGUIDUniqueness.length; j++)
+				{
+					pPict.MeadowIntegrationTabularTransform.addRecordToComprehension(tmpIncomingRecord, tmpMappingOutcome, tmpMappingRecordSolution.NewRecordPrototype, tmpMappingRecordSolution.NewRecordsGUIDUniqueness[j]);
+				}
+			}
+			else if (!tmpMappingOutcome.Configuration.MultipleGUIDUniqueness)
+			{
+				pPict.MeadowIntegrationTabularTransform.addRecordToComprehension(tmpIncomingRecord, tmpMappingOutcome, tmpMappingRecordSolution.NewRecordPrototype);
+			}
+		}
+	}
+
+	pPict.log.info(`JSON Array Transform: Parsed ${tmpMappingOutcome.ParsedRowCount} records from [${pDatasetName}].`);
+	return { MappingOutcome: tmpMappingOutcome };
+}

package/source/services/meadow-integration/MeadowIntegration-Command-TSVCheck.js

@@ -0,0 +1,80 @@
+/**
+ * MeadowIntegration Command - TSV Check
+ *
+ * POST /1.0/Retold/MeadowIntegration/TSV/Check
+ *
+ * Analyze a TSV file for statistics.
+ *
+ * Body: { "File": "/path/to/file.tsv", "Records": false }
+ * Returns: Statistics JSON
+ */
+const libFS = require('fs');
+const libReadline = require('readline');
+
+module.exports = function(pIntegrationService, pOratorServiceServer)
+{
+	let tmpPict = pIntegrationService.pict;
+
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/TSV/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();
+			}
+
+			let tmpInputFilePath = tmpPict.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!tmpPict.FilePersistence.existsSync(tmpInputFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpInputFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpCSVParser = tmpPict.instantiateServiceProviderWithoutRegistration('CSVParser');
+			tmpCSVParser.Delimiter = '\t';
+
+			let tmpStatistics = tmpPict.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)
+					{
+						tmpPict.MeadowIntegrationTabularCheck.collectStatistics(tmpRecord, tmpStatistics, tmpStoreFullRecord);
+					}
+				});
+
+			tmpReadline.on('close',
+				() =>
+				{
+					tmpPict.log.info(`TSV Check: ${tmpStatistics.RowCount} rows, ${tmpStatistics.ColumnCount} columns in [${tmpInputFilePath}].`);
+					pResponse.send(200, tmpStatistics);
+					return fNext();
+				});
+
+			tmpReadline.on('error',
+				(pError) =>
+				{
+					tmpPict.log.error(`TSV Check error reading file [${tmpInputFilePath}]: ${pError}`, pError);
+					pResponse.send(500, { Error: `Error reading TSV file: ${pError.message}` });
+					return fNext();
+				});
+		});
+};

package/source/services/meadow-integration/MeadowIntegration-Command-TSVTransform.js

@@ -0,0 +1,166 @@
+/**
+ * MeadowIntegration Command - TSV Transform
+ *
+ * POST /1.0/Retold/MeadowIntegration/TSV/Transform
+ *
+ * Transform a TSV file into a comprehension using mapping configuration.
+ *
+ * Body: same as CSV Transform but for TSV files.
+ * Returns: Comprehension JSON (or extended state if Extended=true)
+ */
+const libFS = require('fs');
+const libPath = require('path');
+const libReadline = require('readline');
+
+module.exports = function(pIntegrationService, pOratorServiceServer)
+{
+	let tmpPict = pIntegrationService.pict;
+
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/TSV/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();
+			}
+
+			let tmpInputFilePath = tmpPict.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!tmpPict.FilePersistence.existsSync(tmpInputFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpInputFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpCSVParser = tmpPict.instantiateServiceProviderWithoutRegistration('CSVParser');
+			tmpCSVParser.Delimiter = '\t';
+
+			let tmpMappingOutcome = tmpPict.MeadowIntegrationTabularTransform.newMappingOutcomeObject();
+
+			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;
+			}
+			if (tmpBody.MappingConfiguration && (typeof(tmpBody.MappingConfiguration) === 'object'))
+			{
+				tmpMappingOutcome.ExplicitConfiguration = tmpBody.MappingConfiguration;
+			}
+			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 = tmpPict.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: tmpPict,
+								Pict: tmpPict,
+								AppData: tmpPict.AppData
+							});
+
+						let tmpSolverResultsObject = {};
+						if (tmpMappingOutcome.Configuration.Solvers && Array.isArray(tmpMappingOutcome.Configuration.Solvers))
+						{
+							for (let i = 0; i < tmpMappingOutcome.Configuration.Solvers.length; i++)
+							{
+								tmpPict.ExpressionParser.solve(tmpMappingOutcome.Configuration.Solvers[i], tmpMappingRecordSolution, tmpSolverResultsObject, tmpPict.manifest, tmpMappingRecordSolution);
+							}
+						}
+
+						if (tmpMappingOutcome.Configuration.MultipleGUIDUniqueness && tmpMappingRecordSolution.NewRecordsGUIDUniqueness.length > 0)
+						{
+							for (let i = 0; i < tmpMappingRecordSolution.NewRecordsGUIDUniqueness.length; i++)
+							{
+								tmpPict.MeadowIntegrationTabularTransform.addRecordToComprehension(tmpIncomingRecord, tmpMappingOutcome, tmpMappingRecordSolution.NewRecordPrototype, tmpMappingRecordSolution.NewRecordsGUIDUniqueness[i]);
+							}
+						}
+						else if (!tmpMappingOutcome.Configuration.MultipleGUIDUniqueness)
+						{
+							tmpPict.MeadowIntegrationTabularTransform.addRecordToComprehension(tmpIncomingRecord, tmpMappingOutcome, tmpMappingRecordSolution.NewRecordPrototype);
+						}
+					}
+				});
+
+			tmpReadline.on('close',
+				() =>
+				{
+					tmpPict.log.info(`TSV 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) =>
+				{
+					tmpPict.log.error(`TSV Transform error reading file [${tmpInputFilePath}]: ${pError}`, pError);
+					pResponse.send(500, { Error: `Error reading TSV file: ${pError.message}` });
+					return fNext();
+				});
+		});
+};