meadow-integration 1.0.1 → 1.0.4

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

@@ -0,0 +1,121 @@
+/**
+ * POST /1.0/Comprehension/ToArray
+ *
+ * Convert an object-based comprehension into an array.
+ *
+ * Request body (JSON):
+ * {
+ *   "Comprehension": { ... },                 // The comprehension object to convert
+ *   "Entity": "MyEntity"                      // (optional) Entity name; auto-inferred if omitted
+ * }
+ *
+ * OR file-based:
+ *
+ * POST /1.0/Comprehension/ToArrayFromFile
+ * {
+ *   "File": "/path/to/comprehension.json",    // Comprehension file path
+ *   "Entity": "MyEntity"                      // (optional) Entity name
+ * }
+ *
+ * Response: JSON array of records
+ */
+module.exports = function(pFable, pOrator)
+{
+	// In-memory conversion
+	pOrator.serviceServer.postWithBodyParser('/1.0/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(pFable, tmpBody.Comprehension, tmpBody.Entity);
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			pResponse.send(200, tmpResult.RecordArray);
+			return fNext();
+		});
+
+	// File-based conversion
+	pOrator.serviceServer.postWithBodyParser('/1.0/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();
+			}
+
+			pFable.instantiateServiceProvider('FilePersistence');
+
+			let tmpFilePath = pFable.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!pFable.FilePersistence.existsSync(tmpFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpComprehension;
+			try
+			{
+				tmpComprehension = JSON.parse(pFable.FilePersistence.readFileSync(tmpFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing comprehension file: ${pError.message}` });
+				return fNext();
+			}
+
+			let tmpResult = processComprehensionToArray(pFable, tmpComprehension, tmpBody.Entity);
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			pResponse.send(200, tmpResult.RecordArray);
+			return fNext();
+		});
+};
+
+function processComprehensionToArray(pFable, pComprehension, pEntity)
+{
+	let tmpEntity = pEntity;
+
+	if (!tmpEntity)
+	{
+		let tmpEntityInference = Object.keys(pComprehension);
+		if (tmpEntityInference.length > 0)
+		{
+			tmpEntity = tmpEntityInference[0];
+			pFable.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]]);
+	}
+
+	pFable.log.info(`Comprehension ToArray: Converted ${tmpRecordArray.length} records for entity [${tmpEntity}].`);
+	return { RecordArray: tmpRecordArray };
+}

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

@@ -0,0 +1,166 @@
+const libPath = require('path');
+
+/**
+ * POST /1.0/Comprehension/Intersect
+ *
+ * Merge two comprehension objects together.
+ *
+ * Request body (JSON):
+ * {
+ *   "PrimaryComprehension": { ... },          // The primary comprehension object
+ *   "SecondaryComprehension": { ... },        // The secondary comprehension to merge in
+ *   "Entity": "MyEntity"                      // (optional) Entity name; auto-inferred if omitted
+ * }
+ *
+ * OR file-based:
+ *
+ * POST /1.0/Comprehension/IntersectFiles
+ * {
+ *   "File": "/path/to/primary.json",          // Primary comprehension file
+ *   "IntersectFile": "/path/to/secondary.json",// Secondary comprehension file
+ *   "Entity": "MyEntity"                      // (optional) Entity name
+ * }
+ *
+ * Response: Merged comprehension JSON
+ */
+module.exports = function(pFable, pOrator)
+{
+	// In-memory intersection
+	pOrator.serviceServer.postWithBodyParser('/1.0/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(pFable, 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
+	pOrator.serviceServer.postWithBodyParser('/1.0/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();
+			}
+
+			pFable.instantiateServiceProvider('FilePersistence');
+
+			let tmpPrimaryFilePath = pFable.FilePersistence.resolvePath(tmpBody.File);
+			let tmpSecondaryFilePath = pFable.FilePersistence.resolvePath(tmpBody.IntersectFile);
+
+			if (!pFable.FilePersistence.existsSync(tmpPrimaryFilePath))
+			{
+				pResponse.send(404, { Error: `Primary file [${tmpPrimaryFilePath}] does not exist.` });
+				return fNext();
+			}
+			if (!pFable.FilePersistence.existsSync(tmpSecondaryFilePath))
+			{
+				pResponse.send(404, { Error: `Secondary file [${tmpSecondaryFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpPrimaryComprehension;
+			let tmpSecondaryComprehension;
+
+			try
+			{
+				tmpPrimaryComprehension = JSON.parse(pFable.FilePersistence.readFileSync(tmpPrimaryFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing primary comprehension file: ${pError.message}` });
+				return fNext();
+			}
+
+			try
+			{
+				tmpSecondaryComprehension = JSON.parse(pFable.FilePersistence.readFileSync(tmpSecondaryFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing secondary comprehension file: ${pError.message}` });
+				return fNext();
+			}
+
+			let tmpResult = processComprehensionIntersect(pFable, tmpPrimaryComprehension, tmpSecondaryComprehension, tmpBody.Entity);
+			if (tmpResult.Error)
+			{
+				pResponse.send(400, tmpResult);
+				return fNext();
+			}
+
+			pResponse.send(200, tmpResult.Comprehension);
+			return fNext();
+		});
+};
+
+function processComprehensionIntersect(pFable, pPrimaryComprehension, pSecondaryComprehension, pEntity)
+{
+	let tmpEntity = pEntity;
+
+	if (!tmpEntity)
+	{
+		let tmpEntityInference = Object.keys(pPrimaryComprehension);
+		if (tmpEntityInference.length > 0)
+		{
+			tmpEntity = tmpEntityInference[0];
+			pFable.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.' };
+		}
+	}
+
+	// Deep clone the primary to avoid mutation
+	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];
+		}
+	}
+
+	pFable.log.info(`Comprehension Intersect: Merged ${tmpIntersectingKeys.length} records for entity [${tmpEntity}].`);
+	return { Comprehension: tmpResultComprehension };
+}

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

@@ -0,0 +1,209 @@
+const libPath = require('path');
+
+const libIntegrationAdapter = require('../../Meadow-Service-Integration-Adapter.js');
+
+/**
+ * POST /1.0/Comprehension/Push
+ *
+ * Push a comprehension to Meadow REST APIs via the Integration Adapter.
+ *
+ * Request body (JSON):
+ * {
+ *   "Comprehension": { ... },                 // The comprehension object to push
+ *   "GUIDPrefix": "INTG-",                    // (optional) GUID prefix for the comprehension push
+ *   "EntityGUIDPrefix": "E-",                 // (optional) GUID prefix per entity
+ *   "ServerURL": "http://localhost:8086/1.0/"  // (optional) Target Meadow API server URL
+ * }
+ *
+ * OR file-based:
+ *
+ * POST /1.0/Comprehension/PushFile
+ * {
+ *   "File": "/path/to/comprehension.json",    // Comprehension file path
+ *   "GUIDPrefix": "INTG-",                    // (optional) GUID prefix
+ *   "EntityGUIDPrefix": "E-",                 // (optional) Entity GUID prefix
+ *   "ServerURL": "http://localhost:8086/1.0/"  // (optional) Target Meadow API server URL
+ * }
+ *
+ * Response: { "Success": true, "EntitiesPushed": [...], "Message": "..." }
+ */
+module.exports = function(pFable, pOrator)
+{
+	// In-memory push
+	pOrator.serviceServer.postWithBodyParser('/1.0/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(pFable, 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
+	pOrator.serviceServer.postWithBodyParser('/1.0/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();
+			}
+
+			pFable.instantiateServiceProvider('FilePersistence');
+
+			let tmpFilePath = pFable.FilePersistence.resolvePath(tmpBody.File);
+
+			if (!pFable.FilePersistence.existsSync(tmpFilePath))
+			{
+				pResponse.send(404, { Error: `File [${tmpFilePath}] does not exist.` });
+				return fNext();
+			}
+
+			let tmpComprehension;
+			try
+			{
+				tmpComprehension = JSON.parse(pFable.FilePersistence.readFileSync(tmpFilePath));
+			}
+			catch (pError)
+			{
+				pResponse.send(400, { Error: `Error parsing comprehension file: ${pError.message}` });
+				return fNext();
+			}
+
+			pushComprehension(pFable, 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(pFable, pComprehension, pOptions, fCallback)
+{
+	pFable.serviceManager.addServiceType('IntegrationAdapter', libIntegrationAdapter);
+
+	let tmpAnticipate = pFable.newAnticipate();
+	let tmpEntitiesPushed = [];
+
+	let tmpIntegrationAdapterSet = Object.keys(pComprehension);
+
+	pFable.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];
+					let tmpAdapterOptions = { Entity: tmpAdapterKey, EntityGUIDMarshalPrefix: getCapitalLettersAsString(tmpAdapterKey) };
+
+					if (pOptions.ServerURL)
+					{
+						tmpAdapterOptions.ServerURL = pOptions.ServerURL;
+					}
+
+					libIntegrationAdapter.getAdapter(pFable, tmpAdapterKey, getCapitalLettersAsString(tmpAdapterKey), { SimpleMarshal: true, ForceMarshal: true });
+
+					let tmpAdapter = pFable.servicesMap.IntegrationAdapter[tmpAdapterKey];
+
+					if (pOptions.GUIDPrefix)
+					{
+						tmpAdapter.AdapterSetGUIDMarshalPrefix = pOptions.GUIDPrefix;
+					}
+					if (pOptions.EntityGUIDPrefix)
+					{
+						tmpAdapter.EntityGUIDMarshalPrefix = pOptions.EntityGUIDPrefix;
+					}
+
+					let tmpDataMap = pComprehension[tmpAdapterKey];
+					if (!tmpDataMap)
+					{
+						pFable.log.info(`No records to push for [${tmpAdapterKey}].`);
+						continue;
+					}
+
+					tmpEntitiesPushed.push(tmpAdapterKey);
+
+					// Add source records
+					tmpAnticipate.anticipate(
+						(function(pAdapter, pDataMap)
+						{
+							return function(fRecordDone)
+							{
+								for (const tmpRecord in pDataMap)
+								{
+									pAdapter.addSourceRecord(pDataMap[tmpRecord]);
+								}
+								return fRecordDone();
+							};
+						})(tmpAdapter, tmpDataMap));
+
+					// Integrate records
+					tmpAnticipate.anticipate(
+						(function(pAdapter)
+						{
+							return function(fIntegrateDone)
+							{
+								pAdapter.integrateRecords(fIntegrateDone);
+							};
+						})(tmpAdapter));
+				}
+			}
+			catch (pError)
+			{
+				pFable.log.error(`Error wiring up integration adapters: ${pError}`, pError);
+				return fDone(pError);
+			}
+
+			return fDone();
+		});
+
+	tmpAnticipate.wait(
+		(pError) =>
+		{
+			if (pError)
+			{
+				pFable.log.error(`Error pushing comprehension.`, pError);
+				return fCallback(pError);
+			}
+			pFable.log.info(`Finished pushing comprehension for entities: [${tmpEntitiesPushed.join(', ')}].`);
+			return fCallback(null,
+				{
+					Success: true,
+					EntitiesPushed: tmpEntitiesPushed,
+					Message: `Pushed comprehension for ${tmpEntitiesPushed.length} entity(ies).`
+				});
+		});
+}