retold-data-service 2.0.12 → 2.0.14

package/source/services/Retold-Data-Service-ConnectionManager.js

@@ -0,0 +1,277 @@
+/**
+ * Retold Data Service - Connection Manager
+ *
+ * Fable service that manages named database connections.
+ * Each connection has a name, provider type, provider module,
+ * configuration, and active status.
+ *
+ * Provides REST endpoints under /1.0/Retold/Connection(s) for
+ * managing connections at runtime.
+ *
+ * @author Steven Velozo <steven@velozo.com>
+ */
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+class RetoldDataServiceConnectionManager extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'RetoldDataServiceConnectionManager';
+
+		// Named connection storage: { connectionName: { Name, Provider, ProviderModule, Config, Active } }
+		this.connections = {};
+	}
+
+	/**
+	 * Add a named connection. Stores the definition and instantiates the
+	 * provider service in fable.
+	 *
+	 * @param {string} pName - Connection name
+	 * @param {Object} pConnectionDefinition - Connection config object
+	 * @param {string} pConnectionDefinition.Provider - Provider name (e.g. 'SQLite', 'MySQL')
+	 * @param {string} pConnectionDefinition.ProviderModule - npm module name (e.g. 'meadow-connection-sqlite')
+	 * @param {Object} pConnectionDefinition.Config - Provider-specific configuration
+	 * @param {function} fCallback - Callback invoked as fCallback(pError)
+	 */
+	addConnection(pName, pConnectionDefinition, fCallback)
+	{
+		if (!pName || typeof(pName) !== 'string')
+		{
+			return fCallback(new Error('Connection name is required and must be a string.'));
+		}
+		if (!pConnectionDefinition || !pConnectionDefinition.Provider || !pConnectionDefinition.ProviderModule)
+		{
+			return fCallback(new Error('Connection definition must include Provider and ProviderModule.'));
+		}
+
+		if (this.connections.hasOwnProperty(pName))
+		{
+			this.fable.log.warn(`Connection [${pName}] already exists; overwriting.`);
+		}
+
+		let tmpConnection = (
+			{
+				Name: pName,
+				Provider: pConnectionDefinition.Provider,
+				ProviderModule: pConnectionDefinition.ProviderModule,
+				Config: pConnectionDefinition.Config || {},
+				Active: false
+			});
+
+		this.connections[pName] = tmpConnection;
+
+		// Merge config into fable settings under the provider key
+		// (e.g. fable.settings.SQLite = { SQLiteFilePath: ':memory:' })
+		if (tmpConnection.Config && Object.keys(tmpConnection.Config).length > 0)
+		{
+			this.fable.settings[tmpConnection.Provider] = this.fable.Utility.extend(
+				this.fable.settings[tmpConnection.Provider] || {},
+				tmpConnection.Config);
+		}
+
+		// Instantiate the provider service
+		let tmpServiceTypeName = `Meadow${tmpConnection.Provider}Provider`;
+		try
+		{
+			this.fable.serviceManager.addAndInstantiateServiceType(tmpServiceTypeName, require(tmpConnection.ProviderModule));
+			tmpConnection.Active = true;
+			this.fable.log.info(`Connection [${pName}] added and provider [${tmpServiceTypeName}] instantiated.`);
+		}
+		catch (pError)
+		{
+			this.fable.log.error(`Error instantiating provider for connection [${pName}]: ${pError}`);
+			return fCallback(pError);
+		}
+
+		return fCallback();
+	}
+
+	/**
+	 * Remove a named connection.
+	 *
+	 * @param {string} pName - Connection name
+	 * @param {function} fCallback - Callback invoked as fCallback(pError)
+	 */
+	removeConnection(pName, fCallback)
+	{
+		if (!this.connections.hasOwnProperty(pName))
+		{
+			return fCallback(new Error(`Connection [${pName}] does not exist.`));
+		}
+
+		delete this.connections[pName];
+		this.fable.log.info(`Connection [${pName}] removed.`);
+		return fCallback();
+	}
+
+	/**
+	 * Test a named connection by verifying the provider service exists and is reachable.
+	 *
+	 * @param {string} pName - Connection name
+	 * @param {function} fCallback - Callback invoked as fCallback(pError, pResult)
+	 */
+	testConnection(pName, fCallback)
+	{
+		if (!this.connections.hasOwnProperty(pName))
+		{
+			return fCallback(new Error(`Connection [${pName}] does not exist.`));
+		}
+
+		let tmpConnection = this.connections[pName];
+		let tmpServiceTypeName = `Meadow${tmpConnection.Provider}Provider`;
+
+		// Check that the provider service is available in fable
+		let tmpProviderService = this.fable[tmpServiceTypeName];
+		if (!tmpProviderService)
+		{
+			return fCallback(null, { Connection: pName, Status: 'Error', Message: `Provider service [${tmpServiceTypeName}] not found in fable.` });
+		}
+
+		// If the provider has a connected property, check it
+		if (typeof(tmpProviderService.connected) !== 'undefined')
+		{
+			return fCallback(null, { Connection: pName, Status: tmpProviderService.connected ? 'Connected' : 'Disconnected', Provider: tmpConnection.Provider });
+		}
+
+		// Provider exists but no connected flag
+		return fCallback(null, { Connection: pName, Status: 'Available', Provider: tmpConnection.Provider });
+	}
+
+	/**
+	 * Get a single connection's metadata (without sensitive config details).
+	 *
+	 * @param {string} pName - Connection name
+	 * @return {Object|false} Connection metadata or false if not found
+	 */
+	getConnection(pName)
+	{
+		if (!this.connections.hasOwnProperty(pName))
+		{
+			return false;
+		}
+
+		let tmpConnection = this.connections[pName];
+		return (
+			{
+				Name: tmpConnection.Name,
+				Provider: tmpConnection.Provider,
+				Active: tmpConnection.Active
+			});
+	}
+
+	/**
+	 * Get summary metadata for all connections.
+	 *
+	 * @return {Array} Array of connection summaries
+	 */
+	getConnections()
+	{
+		let tmpConnectionList = [];
+		let tmpConnectionNames = Object.keys(this.connections);
+
+		for (let i = 0; i < tmpConnectionNames.length; i++)
+		{
+			tmpConnectionList.push(this.getConnection(tmpConnectionNames[i]));
+		}
+
+		return tmpConnectionList;
+	}
+
+	/**
+	 * Register REST routes for connection management on the Orator service server.
+	 *
+	 * @param {Object} pOratorServiceServer - The Orator ServiceServer instance
+	 */
+	connectRoutes(pOratorServiceServer)
+	{
+		let tmpSelf = this;
+
+		// GET /1.0/Retold/Connections — list all connections
+		pOratorServiceServer.get('/1.0/Retold/Connections',
+			(pRequest, pResponse, fNext) =>
+			{
+				pResponse.send(200, tmpSelf.getConnections());
+				return fNext();
+			});
+
+		// GET /1.0/Retold/Connection/:Name — get a single connection
+		pOratorServiceServer.get('/1.0/Retold/Connection/:Name',
+			(pRequest, pResponse, fNext) =>
+			{
+				let tmpConnection = tmpSelf.getConnection(pRequest.params.Name);
+				if (!tmpConnection)
+				{
+					pResponse.send(404, { Error: `Connection [${pRequest.params.Name}] not found.` });
+					return fNext();
+				}
+				pResponse.send(200, tmpConnection);
+				return fNext();
+			});
+
+		// POST /1.0/Retold/Connection — add a connection
+		pOratorServiceServer.postWithBodyParser('/1.0/Retold/Connection',
+			(pRequest, pResponse, fNext) =>
+			{
+				let tmpBody = pRequest.body;
+				if (!tmpBody || !tmpBody.Name)
+				{
+					pResponse.send(400, { Error: 'Request body must include Name, Provider, and ProviderModule.' });
+					return fNext();
+				}
+
+				tmpSelf.addConnection(tmpBody.Name, tmpBody,
+					(pError) =>
+					{
+						if (pError)
+						{
+							pResponse.send(500, { Error: pError.message });
+							return fNext();
+						}
+						pResponse.send(200, tmpSelf.getConnection(tmpBody.Name));
+						return fNext();
+					});
+			});
+
+		// DEL /1.0/Retold/Connection/:Name — remove a connection
+		pOratorServiceServer.del('/1.0/Retold/Connection/:Name',
+			(pRequest, pResponse, fNext) =>
+			{
+				tmpSelf.removeConnection(pRequest.params.Name,
+					(pError) =>
+					{
+						if (pError)
+						{
+							pResponse.send(404, { Error: pError.message });
+							return fNext();
+						}
+						pResponse.send(200, { Message: `Connection [${pRequest.params.Name}] removed.` });
+						return fNext();
+					});
+			});
+
+		// GET /1.0/Retold/Connection/:Name/Test — test a connection
+		pOratorServiceServer.get('/1.0/Retold/Connection/:Name/Test',
+			(pRequest, pResponse, fNext) =>
+			{
+				tmpSelf.testConnection(pRequest.params.Name,
+					(pError, pResult) =>
+					{
+						if (pError)
+						{
+							pResponse.send(404, { Error: pError.message });
+							return fNext();
+						}
+						pResponse.send(200, pResult);
+						return fNext();
+					});
+			});
+
+		this.fable.log.info('Retold Data Service ConnectionManager routes registered.');
+	}
+}
+
+module.exports = RetoldDataServiceConnectionManager;
+module.exports.serviceType = 'RetoldDataServiceConnectionManager';
+module.exports.default_configuration = {};

package/source/services/Retold-Data-Service-MeadowEndpoints.js

@@ -0,0 +1,217 @@
+/**
+ * Retold Data Service - Meadow Endpoints Service
+ *
+ * Fable service responsible for loading compiled model schemas,
+ * creating DAL objects and Meadow Endpoints for each entity,
+ * and connecting their routes to Orator.
+ *
+ * Supports loading multiple named models. All entities across
+ * all models are merged into flat _DAL and _MeadowEndpoints maps.
+ *
+ * @author Steven Velozo <steven@velozo.com>
+ */
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libMeadow = require('meadow');
+const libMeadowEndpoints = require('meadow-endpoints');
+
+const defaultMeadowEndpointsSettings = (
+	{
+		StorageProvider: 'MySQL',
+
+		FullMeadowSchemaPath: `${process.cwd()}/model/`,
+		FullMeadowSchemaFilename: `MeadowModel-Extended.json`
+	});
+
+class RetoldDataServiceMeadowEndpoints extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		let tmpOptions = Object.assign({}, JSON.parse(JSON.stringify(defaultMeadowEndpointsSettings)), pOptions);
+		super(pFable, tmpOptions, pServiceHash);
+
+		this.serviceType = 'RetoldDataServiceMeadowEndpoints';
+
+		this._Meadow = libMeadow.new(pFable);
+
+		this._DAL = {};
+		this._MeadowEndpoints = {};
+
+		// Named model storage -- each key is a model name, value is the parsed model object
+		this.models = {};
+
+		// Merged view across all models (rebuilt on each loadModel call)
+		this.fullModel = false;
+		this.entityList = false;
+	}
+
+	/**
+	 * Rebuild the merged fullModel and entityList from all loaded models.
+	 *
+	 * Called internally after each loadModel to keep the merged view current.
+	 */
+	rebuildFullModel()
+	{
+		let tmpModelNames = Object.keys(this.models);
+
+		if (tmpModelNames.length === 0)
+		{
+			this.fullModel = false;
+			this.entityList = false;
+			return;
+		}
+
+		let tmpMergedModel = (
+			{
+				Tables: {},
+				TablesSequence: [],
+				Authorization: {},
+				Endpoints: {},
+				Pict: {}
+			});
+
+		for (let i = 0; i < tmpModelNames.length; i++)
+		{
+			let tmpModel = this.models[tmpModelNames[i]];
+
+			if (tmpModel.Tables)
+			{
+				Object.assign(tmpMergedModel.Tables, tmpModel.Tables);
+			}
+			if (tmpModel.TablesSequence)
+			{
+				tmpMergedModel.TablesSequence = tmpMergedModel.TablesSequence.concat(tmpModel.TablesSequence);
+			}
+			if (tmpModel.Authorization)
+			{
+				Object.assign(tmpMergedModel.Authorization, tmpModel.Authorization);
+			}
+			if (tmpModel.Endpoints)
+			{
+				Object.assign(tmpMergedModel.Endpoints, tmpModel.Endpoints);
+			}
+			if (tmpModel.Pict)
+			{
+				Object.assign(tmpMergedModel.Pict, tmpModel.Pict);
+			}
+		}
+
+		this.fullModel = tmpMergedModel;
+		this.entityList = Object.keys(this._DAL);
+	}
+
+	/**
+	 * Load a parsed model object and create DAL objects and Meadow Endpoints
+	 * for each entity in it.
+	 *
+	 * @param {string} pModelName - A name to identify this model
+	 * @param {Object} pModelObject - The parsed stricture model (MeadowModel-Extended.json format)
+	 * @param {string} [pStorageProvider] - Optional storage provider name override (e.g. 'SQLite', 'MySQL')
+	 * @param {function} fCallback - Callback invoked as fCallback(pError) on completion
+	 */
+	loadModel(pModelName, pModelObject, pStorageProvider, fCallback)
+	{
+		// Handle optional pStorageProvider parameter
+		let tmpCallback = fCallback;
+		let tmpStorageProvider = pStorageProvider;
+		if (typeof(pStorageProvider) === 'function')
+		{
+			tmpCallback = pStorageProvider;
+			tmpStorageProvider = this.options.StorageProvider;
+		}
+
+		this.fable.log.info(`Retold Data Service loading model [${pModelName}]...`);
+
+		if (this.models.hasOwnProperty(pModelName))
+		{
+			this.fable.log.warn(`Model [${pModelName}] is already loaded; overwriting.`);
+		}
+
+		this.models[pModelName] = pModelObject;
+
+		let tmpEntityList = Object.keys(pModelObject.Tables);
+
+		this.fable.log.info(`...initializing ${tmpEntityList.length} DAL objects and corresponding Meadow Endpoints for model [${pModelName}]...`);
+
+		for (let i = 0; i < tmpEntityList.length; i++)
+		{
+			let tmpDALEntityName = tmpEntityList[i];
+
+			if (this._DAL.hasOwnProperty(tmpDALEntityName))
+			{
+				this.fable.log.warn(`Entity [${tmpDALEntityName}] already exists in the DAL (from another model); overwriting.`);
+			}
+
+			try
+			{
+				let tmpDALSchema = pModelObject.Tables[tmpDALEntityName];
+				let tmpDALMeadowSchema = tmpDALSchema.MeadowSchema;
+
+				this._DAL[tmpDALEntityName] = this._Meadow.loadFromPackageObject(tmpDALMeadowSchema);
+				this.fable.log.info(`...defaulting the ${tmpDALEntityName} DAL to use ${tmpStorageProvider}`);
+				this._DAL[tmpDALEntityName].setProvider(tmpStorageProvider);
+				this.fable.log.info(`...initializing the ${tmpDALEntityName} Meadow Endpoints`);
+				this._MeadowEndpoints[tmpDALEntityName] = libMeadowEndpoints.new(this._DAL[tmpDALEntityName]);
+				this.fable.log.info(`...mapping the ${tmpDALEntityName} Meadow Endpoints to Orator`);
+				this._MeadowEndpoints[tmpDALEntityName].connectRoutes(this.fable.OratorServiceServer);
+			}
+			catch (pError)
+			{
+				this.fable.log.error(`Error initializing DAL and Endpoints for entity [${tmpDALEntityName}]: ${pError}`);
+			}
+		}
+
+		this.rebuildFullModel();
+
+		return tmpCallback();
+	}
+
+	/**
+	 * Load a model from a JSON file on disk.
+	 *
+	 * @param {string} pModelName - A name to identify this model
+	 * @param {string} pModelPath - Directory path containing the model file
+	 * @param {string} pModelFilename - The model JSON filename
+	 * @param {function} fCallback - Callback invoked as fCallback(pError) on completion
+	 */
+	loadModelFromFile(pModelName, pModelPath, pModelFilename, fCallback)
+	{
+		this.fable.log.info(`...loading model [${pModelName}] from file [${pModelPath}${pModelFilename}]...`);
+
+		let tmpModelObject;
+		try
+		{
+			tmpModelObject = require(`${pModelPath}${pModelFilename}`);
+		}
+		catch (pError)
+		{
+			this.fable.log.error(`Error loading model file [${pModelPath}${pModelFilename}]: ${pError}`);
+			return fCallback(pError);
+		}
+
+		return this.loadModel(pModelName, tmpModelObject, fCallback);
+	}
+
+	/**
+	 * Initialize data endpoints by loading the default model from options.
+	 *
+	 * This is the standard initialization path used by initializeService
+	 * in the main RetoldDataService. Loads a single model using the configured
+	 * FullMeadowSchemaPath and FullMeadowSchemaFilename options.
+	 *
+	 * @param {function} fCallback - Callback invoked as fCallback(pError) on completion
+	 */
+	initializeDataEndpoints(fCallback)
+	{
+		this.fable.log.info("Retold Data Service initializing Endpoints...");
+
+		// Derive a model name from the filename (e.g. "MeadowModel-Extended.json" -> "MeadowModel-Extended")
+		let tmpModelName = this.options.FullMeadowSchemaFilename.replace(/\.json$/i, '');
+
+		return this.loadModelFromFile(tmpModelName, this.options.FullMeadowSchemaPath, this.options.FullMeadowSchemaFilename, fCallback);
+	}
+}
+
+module.exports = RetoldDataServiceMeadowEndpoints;
+module.exports.serviceType = 'RetoldDataServiceMeadowEndpoints';
+module.exports.default_configuration = defaultMeadowEndpointsSettings;