retold-data-service 2.0.13 → 2.0.14

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

@@ -0,0 +1,153 @@
+/**
+ * MeadowIntegration Command - Comprehension Intersect
+ *
+ * POST /1.0/Retold/MeadowIntegration/Comprehension/Intersect
+ *   Merge two in-memory comprehension objects.
+ *
+ * POST /1.0/Retold/MeadowIntegration/Comprehension/IntersectFiles
+ *   Merge two comprehension files.
+ *
+ * Body (in-memory): { "PrimaryComprehension": {...}, "SecondaryComprehension": {...}, "Entity": "..." }
+ * Body (file):      { "File": "/path", "IntersectFile": "/path", "Entity": "..." }
+ * Returns: Merged comprehension JSON
+ */
+module.exports = function(pIntegrationService, pOratorServiceServer)
+{
+	let tmpPict = pIntegrationService.pict;
+
+	// In-memory intersection
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Comprehension/Intersect`,
+		(pRequest, pResponse, fNext) =>
+		{
+			let tmpBody = pRequest.body || {};
+
+			if (!tmpBody.PrimaryComprehension || (typeof(tmpBody.PrimaryComprehension) !== 'object'))
+			{
+				pResponse.send(400, { Error: 'No valid PrimaryComprehension object provided in request body.' });
+				return fNext();
+			}
+			if (!tmpBody.SecondaryComprehension || (typeof(tmpBody.SecondaryComprehension) !== 'object'))
+			{
+				pResponse.send(400, { Error: 'No valid SecondaryComprehension object provided in request body.' });
+				return fNext();
+			}
+
+			let tmpResult = processComprehensionIntersect(tmpPict, tmpBody.PrimaryComprehension, tmpBody.SecondaryComprehension, tmpBody.Entity);
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			pResponse.send(200, tmpResult.Comprehension);
+			return fNext();
+		});
+
+	// File-based intersection
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Comprehension/IntersectFiles`,
+		(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();
+			}
+			if (!tmpBody.IntersectFile || (typeof(tmpBody.IntersectFile) !== 'string'))
+			{
+				pResponse.send(400, { Error: 'No valid IntersectFile path provided in request body.' });
+				return fNext();
+			}
+
+			let tmpPrimaryFilePath = tmpPict.FilePersistence.resolvePath(tmpBody.File);
+			let tmpSecondaryFilePath = tmpPict.FilePersistence.resolvePath(tmpBody.IntersectFile);
+
+			if (!tmpPict.FilePersistence.existsSync(tmpPrimaryFilePath))
+			{
+				pResponse.send(404, { Error: `Primary file [${tmpPrimaryFilePath}] does not exist.` });
+				return fNext();
+			}
+			if (!tmpPict.FilePersistence.existsSync(tmpSecondaryFilePath))
+			{
+				pResponse.send(404, { Error: `Secondary file [${tmpSecondaryFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpPrimaryComprehension;
+			let tmpSecondaryComprehension;
+
+			try
+			{
+				tmpPrimaryComprehension = JSON.parse(tmpPict.FilePersistence.readFileSync(tmpPrimaryFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing primary comprehension file: ${pError.message}` });
+				return fNext();
+			}
+
+			try
+			{
+				tmpSecondaryComprehension = JSON.parse(tmpPict.FilePersistence.readFileSync(tmpSecondaryFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing secondary comprehension file: ${pError.message}` });
+				return fNext();
+			}
+
+			let tmpResult = processComprehensionIntersect(tmpPict, tmpPrimaryComprehension, tmpSecondaryComprehension, tmpBody.Entity);
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			pResponse.send(200, tmpResult.Comprehension);
+			return fNext();
+		});
+};
+
+function processComprehensionIntersect(pPict, pPrimaryComprehension, pSecondaryComprehension, pEntity)
+{
+	let tmpEntity = pEntity;
+
+	if (!tmpEntity)
+	{
+		let tmpEntityInference = Object.keys(pPrimaryComprehension);
+		if (tmpEntityInference.length > 0)
+		{
+			tmpEntity = tmpEntityInference[0];
+			pPict.log.info(`No entity specified. Using [${tmpEntity}] as the inferred entity.`);
+		}
+		else
+		{
+			return { Error: 'No entity specified and no entities found in the primary comprehension.' };
+		}
+	}
+
+	let tmpResultComprehension = JSON.parse(JSON.stringify(pPrimaryComprehension));
+
+	if (!tmpResultComprehension[tmpEntity])
+	{
+		tmpResultComprehension[tmpEntity] = {};
+	}
+
+	let tmpIntersectingKeys = Object.keys(pSecondaryComprehension[tmpEntity] || {});
+	for (let i = 0; i < tmpIntersectingKeys.length; i++)
+	{
+		const tmpRecordGUID = tmpIntersectingKeys[i];
+		if (tmpResultComprehension[tmpEntity][tmpRecordGUID])
+		{
+			tmpResultComprehension[tmpEntity][tmpRecordGUID] = Object.assign(tmpResultComprehension[tmpEntity][tmpRecordGUID], pSecondaryComprehension[tmpEntity][tmpRecordGUID]);
+		}
+		else
+		{
+			tmpResultComprehension[tmpEntity][tmpRecordGUID] = pSecondaryComprehension[tmpEntity][tmpRecordGUID];
+		}
+	}
+
+	pPict.log.info(`Comprehension Intersect: Merged ${tmpIntersectingKeys.length} records for entity [${tmpEntity}].`);
+	return { Comprehension: tmpResultComprehension };
+}

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

@@ -0,0 +1,190 @@
+/**
+ * MeadowIntegration Command - Comprehension Push
+ *
+ * POST /1.0/Retold/MeadowIntegration/Comprehension/Push
+ *   Push an in-memory comprehension to Meadow REST APIs.
+ *
+ * POST /1.0/Retold/MeadowIntegration/Comprehension/PushFile
+ *   Push a comprehension file to Meadow REST APIs.
+ *
+ * Body (in-memory): { "Comprehension": {...}, "GUIDPrefix": "INTG-", "EntityGUIDPrefix": "E-", "ServerURL": "..." }
+ * Body (file):      { "File": "/path", "GUIDPrefix": "INTG-", "ServerURL": "..." }
+ * Returns: { "Success": true, "EntitiesPushed": [...], "Message": "..." }
+ */
+module.exports = function(pIntegrationService, pOratorServiceServer)
+{
+	let tmpPict = pIntegrationService.pict;
+	let tmpIntegrationAdapter = pIntegrationService.IntegrationAdapter;
+
+	// In-memory push
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Comprehension/Push`,
+		(pRequest, pResponse, fNext) =>
+		{
+			let tmpBody = pRequest.body || {};
+
+			if (!tmpBody.Comprehension || (typeof(tmpBody.Comprehension) !== 'object'))
+			{
+				pResponse.send(400, { Error: 'No valid Comprehension object provided in request body.' });
+				return fNext();
+			}
+
+			pushComprehension(tmpPict, tmpIntegrationAdapter, tmpBody.Comprehension, tmpBody,
+				(pError, pResult) =>
+				{
+					if (pError)
+					{
+						pResponse.send(500, { Error: `Error pushing comprehension: ${pError.message || pError}` });
+						return fNext();
+					}
+					pResponse.send(200, pResult);
+					return fNext();
+				});
+		});
+
+	// File-based push
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Comprehension/PushFile`,
+		(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 tmpFilePath = tmpPict.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!tmpPict.FilePersistence.existsSync(tmpFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpComprehension;
+			try
+			{
+				tmpComprehension = JSON.parse(tmpPict.FilePersistence.readFileSync(tmpFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing comprehension file: ${pError.message}` });
+				return fNext();
+			}
+
+			pushComprehension(tmpPict, tmpIntegrationAdapter, tmpComprehension, tmpBody,
+				(pError, pResult) =>
+				{
+					if (pError)
+					{
+						pResponse.send(500, { Error: `Error pushing comprehension: ${pError.message || pError}` });
+						return fNext();
+					}
+					pResponse.send(200, pResult);
+					return fNext();
+				});
+		});
+};
+
+function getCapitalLettersAsString(pInputString)
+{
+	let tmpRegex = /[A-Z]/g;
+	let tmpMatch = pInputString.match(tmpRegex);
+	return tmpMatch ? tmpMatch.join('') : 'UNK';
+}
+
+function pushComprehension(pPict, pIntegrationAdapterClass, pComprehension, pOptions, fCallback)
+{
+	pPict.serviceManager.addServiceType('IntegrationAdapter', pIntegrationAdapterClass);
+
+	let tmpAnticipate = pPict.newAnticipate();
+	let tmpEntitiesPushed = [];
+
+	let tmpIntegrationAdapterSet = Object.keys(pComprehension);
+
+	pPict.log.info(`Pushing comprehension with ${tmpIntegrationAdapterSet.length} entity(ies) to Meadow APIs...`);
+
+	tmpAnticipate.anticipate(
+		(fDone) =>
+		{
+			try
+			{
+				for (let i = 0; i < tmpIntegrationAdapterSet.length; i++)
+				{
+					let tmpAdapterKey = tmpIntegrationAdapterSet[i];
+
+					pIntegrationAdapterClass.getAdapter(pPict, tmpAdapterKey, getCapitalLettersAsString(tmpAdapterKey), { SimpleMarshal: true, ForceMarshal: true });
+
+					let tmpAdapter = pPict.servicesMap.IntegrationAdapter[tmpAdapterKey];
+
+					if (pOptions.ServerURL)
+					{
+						tmpAdapter.options.ServerURL = pOptions.ServerURL;
+					}
+					if (pOptions.GUIDPrefix)
+					{
+						tmpAdapter.AdapterSetGUIDMarshalPrefix = pOptions.GUIDPrefix;
+					}
+					if (pOptions.EntityGUIDPrefix)
+					{
+						tmpAdapter.EntityGUIDMarshalPrefix = pOptions.EntityGUIDPrefix;
+					}
+
+					let tmpDataMap = pComprehension[tmpAdapterKey];
+					if (!tmpDataMap)
+					{
+						pPict.log.info(`No records to push for [${tmpAdapterKey}].`);
+						continue;
+					}
+
+					tmpEntitiesPushed.push(tmpAdapterKey);
+
+					tmpAnticipate.anticipate(
+						(function(pAdapter, pDataMap)
+						{
+							return function(fRecordDone)
+							{
+								for (const tmpRecord in pDataMap)
+								{
+									pAdapter.addSourceRecord(pDataMap[tmpRecord]);
+								}
+								return fRecordDone();
+							};
+						})(tmpAdapter, tmpDataMap));
+
+					tmpAnticipate.anticipate(
+						(function(pAdapter)
+						{
+							return function(fIntegrateDone)
+							{
+								pAdapter.integrateRecords(fIntegrateDone);
+							};
+						})(tmpAdapter));
+				}
+			}
+			catch (pError)
+			{
+				pPict.log.error(`Error wiring up integration adapters: ${pError}`, pError);
+				return fDone(pError);
+			}
+
+			return fDone();
+		});
+
+	tmpAnticipate.wait(
+		(pError) =>
+		{
+			if (pError)
+			{
+				pPict.log.error(`Error pushing comprehension.`, pError);
+				return fCallback(pError);
+			}
+			pPict.log.info(`Finished pushing comprehension for entities: [${tmpEntitiesPushed.join(', ')}].`);
+			return fCallback(null,
+				{
+					Success: true,
+					EntitiesPushed: tmpEntitiesPushed,
+					Message: `Pushed comprehension for ${tmpEntitiesPushed.length} entity(ies).`
+				});
+		});
+}

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

@@ -0,0 +1,113 @@
+/**
+ * MeadowIntegration Command - Comprehension To Array
+ *
+ * POST /1.0/Retold/MeadowIntegration/Comprehension/ToArray
+ *   Convert an in-memory comprehension to an array.
+ *
+ * POST /1.0/Retold/MeadowIntegration/Comprehension/ToArrayFromFile
+ *   Convert a comprehension file to an array.
+ *
+ * Body (in-memory): { "Comprehension": {...}, "Entity": "..." }
+ * Body (file):      { "File": "/path", "Entity": "..." }
+ * Returns: JSON array of records
+ */
+module.exports = function(pIntegrationService, pOratorServiceServer)
+{
+	let tmpPict = pIntegrationService.pict;
+
+	// In-memory conversion
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Comprehension/ToArray`,
+		(pRequest, pResponse, fNext) =>
+		{
+			let tmpBody = pRequest.body || {};
+
+			if (!tmpBody.Comprehension || (typeof(tmpBody.Comprehension) !== 'object'))
+			{
+				pResponse.send(400, { Error: 'No valid Comprehension object provided in request body.' });
+				return fNext();
+			}
+
+			let tmpResult = processComprehensionToArray(tmpPict, tmpBody.Comprehension, tmpBody.Entity);
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			pResponse.send(200, tmpResult.RecordArray);
+			return fNext();
+		});
+
+	// File-based conversion
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Comprehension/ToArrayFromFile`,
+		(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 tmpFilePath = tmpPict.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!tmpPict.FilePersistence.existsSync(tmpFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpComprehension;
+			try
+			{
+				tmpComprehension = JSON.parse(tmpPict.FilePersistence.readFileSync(tmpFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing comprehension file: ${pError.message}` });
+				return fNext();
+			}
+
+			let tmpResult = processComprehensionToArray(tmpPict, tmpComprehension, tmpBody.Entity);
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			pResponse.send(200, tmpResult.RecordArray);
+			return fNext();
+		});
+};
+
+function processComprehensionToArray(pPict, pComprehension, pEntity)
+{
+	let tmpEntity = pEntity;
+
+	if (!tmpEntity)
+	{
+		let tmpEntityInference = Object.keys(pComprehension);
+		if (tmpEntityInference.length > 0)
+		{
+			tmpEntity = tmpEntityInference[0];
+			pPict.log.info(`No entity specified. Using [${tmpEntity}] as the inferred entity.`);
+		}
+		else
+		{
+			return { Error: 'No entity specified and no entities found in the comprehension.' };
+		}
+	}
+
+	let tmpEntityRecords = pComprehension[tmpEntity] || {};
+	let tmpRecordArray = [];
+
+	let tmpRecordKeys = Object.keys(tmpEntityRecords);
+	for (let i = 0; i < tmpRecordKeys.length; i++)
+	{
+		tmpRecordArray.push(tmpEntityRecords[tmpRecordKeys[i]]);
+	}
+
+	pPict.log.info(`Comprehension ToArray: Converted ${tmpRecordArray.length} records for entity [${tmpEntity}].`);
+	return { RecordArray: tmpRecordArray };
+}

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

@@ -0,0 +1,211 @@
+/**
+ * MeadowIntegration Command - Comprehension To CSV
+ *
+ * POST /1.0/Retold/MeadowIntegration/Comprehension/ToCSV
+ *   Convert an in-memory comprehension or array to CSV.
+ *
+ * POST /1.0/Retold/MeadowIntegration/Comprehension/ToCSVFromFile
+ *   Convert a comprehension/array file to CSV.
+ *
+ * Body (in-memory): { "Records": [...] } or { "Comprehension": {...}, "Entity": "..." }
+ * Body (file):      { "File": "/path", "Entity": "..." }
+ * Returns: CSV text (Content-Type: text/csv)
+ */
+module.exports = function(pIntegrationService, pOratorServiceServer)
+{
+	let tmpPict = pIntegrationService.pict;
+
+	// In-memory conversion
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Comprehension/ToCSV`,
+		(pRequest, pResponse, fNext) =>
+		{
+			let tmpBody = pRequest.body || {};
+
+			let tmpRecordArray = extractRecordArray(tmpPict, tmpBody);
+			if (tmpRecordArray.Error)
+			{
+				pResponse.send(400, tmpRecordArray);
+				return fNext();
+			}
+
+			let tmpCSV = generateCSV(tmpRecordArray.Records);
+			pResponse.setHeader('Content-Type', 'text/csv');
+			pResponse.setHeader('Content-Disposition', 'attachment; filename="export.csv"');
+			pResponse.sendRaw(200, tmpCSV);
+			return fNext();
+		});
+
+	// File-based conversion
+	pOratorServiceServer.postWithBodyParser(`${pIntegrationService.routePrefix}/Comprehension/ToCSVFromFile`,
+		(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 tmpFilePath = tmpPict.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!tmpPict.FilePersistence.existsSync(tmpFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpRawRecordSet;
+			try
+			{
+				tmpRawRecordSet = JSON.parse(tmpPict.FilePersistence.readFileSync(tmpFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing JSON file: ${pError.message}` });
+				return fNext();
+			}
+
+			let tmpExtractBody = { Entity: tmpBody.Entity };
+			if (Array.isArray(tmpRawRecordSet))
+			{
+				tmpExtractBody.Records = tmpRawRecordSet;
+			}
+			else if (typeof(tmpRawRecordSet) === 'object')
+			{
+				tmpExtractBody.Comprehension = tmpRawRecordSet;
+			}
+
+			let tmpRecordArray = extractRecordArray(tmpPict, tmpExtractBody);
+			if (tmpRecordArray.Error)
+			{
+				pResponse.send(400, tmpRecordArray);
+				return fNext();
+			}
+
+			let tmpCSV = generateCSV(tmpRecordArray.Records);
+			pResponse.setHeader('Content-Type', 'text/csv');
+			pResponse.setHeader('Content-Disposition', 'attachment; filename="export.csv"');
+			pResponse.sendRaw(200, tmpCSV);
+			return fNext();
+		});
+};
+
+function extractRecordArray(pPict, pBody)
+{
+	if (pBody.Records && Array.isArray(pBody.Records))
+	{
+		if (pBody.Records.length < 1)
+		{
+			return { Error: 'Records array is empty.' };
+		}
+		return { Records: pBody.Records };
+	}
+
+	if (pBody.Comprehension && (typeof(pBody.Comprehension) === 'object'))
+	{
+		let tmpEntity = pBody.Entity;
+
+		if (tmpEntity)
+		{
+			if (pBody.Comprehension[tmpEntity])
+			{
+				let tmpRecords;
+				if (Array.isArray(pBody.Comprehension[tmpEntity]))
+				{
+					tmpRecords = pBody.Comprehension[tmpEntity];
+				}
+				else
+				{
+					tmpRecords = Object.values(pBody.Comprehension[tmpEntity]);
+				}
+				if (tmpRecords.length < 1)
+				{
+					return { Error: 'No records found for the specified entity.' };
+				}
+				return { Records: tmpRecords };
+			}
+			else
+			{
+				return { Error: `Entity [${tmpEntity}] not found in comprehension.` };
+			}
+		}
+		else
+		{
+			let tmpKeys = Object.keys(pBody.Comprehension);
+			if (tmpKeys.length === 1 && typeof(pBody.Comprehension[tmpKeys[0]]) === 'object' && !Array.isArray(pBody.Comprehension[tmpKeys[0]]))
+			{
+				pPict.log.info(`Auto-detected entity [${tmpKeys[0]}] from comprehension.`);
+				let tmpRecords = Object.values(pBody.Comprehension[tmpKeys[0]]);
+				if (tmpRecords.length < 1)
+				{
+					return { Error: 'No records found in the auto-detected entity.' };
+				}
+				return { Records: tmpRecords };
+			}
+			else if (tmpKeys.length > 1)
+			{
+				return { Error: `Multiple entities found [${tmpKeys.join(', ')}]. Please specify an Entity.` };
+			}
+			else
+			{
+				return { Error: 'No entities found in the comprehension.' };
+			}
+		}
+	}
+
+	return { Error: 'No valid Records array or Comprehension object provided.' };
+}
+
+function flattenObject(pObject, pAddressPrefix)
+{
+	let tmpPrefix = pAddressPrefix || '';
+	let tmpFlattenedObject = {};
+	for (const [pKey, pValue] of Object.entries(pObject))
+	{
+		const pPropertyPath = tmpPrefix ? `${tmpPrefix}.${pKey}` : pKey;
+		if (pValue && typeof pValue === 'object' && !Array.isArray(pValue))
+		{
+			Object.assign(tmpFlattenedObject, flattenObject(pValue, pPropertyPath));
+		}
+		else
+		{
+			tmpFlattenedObject[pPropertyPath] = pValue;
+		}
+	}
+	return tmpFlattenedObject;
+}
+
+function escapeCSVValue(pValue)
+{
+	if (pValue === null || pValue === undefined) return '';
+	const str = String(pValue);
+	return /[",\n]/.test(str) ? `"${str.replace(/"/g, '""')}"` : str;
+}
+
+function generateCSV(pRecords)
+{
+	const tmpAllKeysSet = new Set();
+	const tmpFlattenedRecords = [];
+
+	for (const tmpRecord of pRecords)
+	{
+		const tmpFlattenedObject = flattenObject(tmpRecord);
+		tmpFlattenedRecords.push(tmpFlattenedObject);
+		for (const tmpKey of Object.keys(tmpFlattenedObject))
+		{
+			tmpAllKeysSet.add(tmpKey);
+		}
+	}
+
+	const tmpAllObjectKeys = Array.from(tmpAllKeysSet).sort();
+
+	let tmpCSV = tmpAllObjectKeys.join(',') + '\n';
+	for (const tmpFlatRecord of tmpFlattenedRecords)
+	{
+		const tmpRow = tmpAllObjectKeys.map((pKey) => escapeCSVValue(tmpFlatRecord[pKey])).join(',');
+		tmpCSV += tmpRow + '\n';
+	}
+
+	return tmpCSV;
+}