meadow-integration 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "meadow-integration",
-    "version": "1.0.5",
+    "version": "1.0.6",
     "description": "Meadow Data Integration",
     "bin": {
         "mdwint": "source/cli/Meadow-Integration-CLI-Run.js"
@@ -16,7 +16,7 @@
     "author": "steven velozo <steven@velozo.com>",
     "license": "MIT",
     "devDependencies": {
-        "quackage": "^1.0.58"
+        "quackage": "^1.0.61"
     },
     "mocha": {
         "diff": true,
@@ -39,7 +39,10 @@
     "dependencies": {
         "fable": "^3.1.63",
         "fable-serviceproviderbase": "^3.0.19",
-        "orator": "^6.0.3",
+        "meadow": "^2.0.28",
+        "meadow-connection-mysql": "^1.0.13",
+        "meadow-connection-mssql": "^1.0.15",
+        "orator": "^6.0.4",
         "orator-serviceserver-restify": "^2.0.9",
         "pict-service-commandlineutility": "^1.0.19"
     }

package/scripts/run.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# capture SIGTERM and SIGINT for graceful shutdown
+trap 'kill -TERM $PID' TERM INT
+
+if [ -z "$RUN_LOCAL_DEV" ]; then
+	node source/cli/Meadow-Integration-CLI-Run.js data-clone &
+	PID=$!
+else
+	node --inspect="0.0.0.0:9229" source/cli/Meadow-Integration-CLI-Run.js data-clone &
+	PID=$!
+fi
+
+wait $PID
+trap - TERM INT
+wait $PID
+EXIT_STATUS=$?
+echo "Service exited with status ${EXIT_STATUS}"

package/source/Meadow-Integration.js

@@ -1,8 +1,22 @@
 const libTabularCheck = require(`./services/tabular/Service-TabularCheck.js`);
 const libIntegrationServer = require(`./restserver/Meadow-Integration-Server.js`);
 
+const libConnectionManager = require(`./services/clone/Meadow-Service-ConnectionManager.js`);
+const libCloneRestClient = require(`./services/clone/Meadow-Service-RestClient.js`);
+const libSync = require(`./services/clone/Meadow-Service-Sync.js`);
+const libSyncEntityInitial = require(`./services/clone/Meadow-Service-Sync-Entity-Initial.js`);
+const libSyncEntityOngoing = require(`./services/clone/Meadow-Service-Sync-Entity-Ongoing.js`);
+const libOperation = require(`./services/clone/Meadow-Service-Operation.js`);
+
 module.exports = (
 	{
 		TabularCheck: libTabularCheck,
-		IntegrationServer: libIntegrationServer
+		IntegrationServer: libIntegrationServer,
+
+		ConnectionManager: libConnectionManager,
+		CloneRestClient: libCloneRestClient,
+		Sync: libSync,
+		SyncEntityInitial: libSyncEntityInitial,
+		SyncEntityOngoing: libSyncEntityOngoing,
+		Operation: libOperation
 	});

package/source/cli/Default-Meadow-Integration-Configuration.json

@@ -1,3 +1,38 @@
 {
-	
-}
+	"Source":
+	{
+		"ServerURL": "https://localhost:8080/1.0/",
+		"UserID": false,
+		"Password": false
+	},
+	"Destination":
+	{
+		"Provider": "MySQL",
+		"MySQL":
+		{
+			"server": "127.0.0.1",
+			"port": 3306,
+			"user": "root",
+			"password": "",
+			"database": "meadow",
+			"connectionLimit": 20
+		},
+		"MSSQL":
+		{
+			"server": "127.0.0.1",
+			"port": 1433,
+			"user": "sa",
+			"password": "",
+			"database": "meadow",
+			"ConnectionPoolLimit": 20
+		}
+	},
+	"SchemaPath": "./schema/Model-Extended.json",
+	"Sync":
+	{
+		"DefaultSyncMode": "Initial",
+		"PageSize": 100,
+		"SyncEntityList": [],
+		"SyncEntityOptions": {}
+	}
+}

package/source/cli/Meadow-Integration-CLI-Program.js

@@ -10,7 +10,7 @@ let _PictCLIProgram = new libCLIProgram(
 
 		DefaultProgramConfiguration: require('./Default-Meadow-Integration-Configuration.json'),
 
-		ProgramConfigurationFileName: '.meadow-integration.json',
+		ProgramConfigurationFileName: '.meadow.config.json',
 		AutoGatherProgramConfiguration: true,
 		AutoAddConfigurationExplanationCommand: true
 	},
@@ -32,6 +32,9 @@ let _PictCLIProgram = new libCLIProgram(
 
 		require('./commands/Meadow-Integration-Command-ComprehensionPush.js'),
 
+		// Data clone
+		require('./commands/Meadow-Integration-Command-DataClone.js'),
+
 		// REST server
 		require('./commands/Meadow-Integration-Command-Serve.js')
 	]);

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

@@ -0,0 +1,284 @@
+const libCLICommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+const libPath = require('path');
+
+const libMeadowConnectionManager = require('../../services/clone/Meadow-Service-ConnectionManager.js');
+const libMeadowCloneRestClient = require('../../services/clone/Meadow-Service-RestClient.js');
+const libMeadowSync = require('../../services/clone/Meadow-Service-Sync.js');
+
+class DataClone extends libCLICommandLineCommand
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.options.CommandKeyword = 'data-clone';
+		this.options.Description = 'Clone data from a Meadow API source to a local database.';
+		this.options.Aliases.push('clone');
+		this.options.Aliases.push('sync');
+
+		this.options.CommandOptions.push({ Name: '-a, --api_server [api_server]', Description: 'The source API server URL.' });
+		this.options.CommandOptions.push({ Name: '-u, --api_username [api_username]', Description: 'The API username to authenticate with.' });
+		this.options.CommandOptions.push({ Name: '-p, --api_password [api_password]', Description: 'The API password to authenticate with.' });
+
+		this.options.CommandOptions.push({ Name: '-d, --db_provider [db_provider]', Description: 'The database provider (MySQL or MSSQL). Default is MySQL.', DefaultValue: 'MySQL' });
+		this.options.CommandOptions.push({ Name: '-dh, --db_host [db_host]', Description: 'The database host address.' });
+		this.options.CommandOptions.push({ Name: '-dp, --db_port [db_port]', Description: 'The database port.' });
+		this.options.CommandOptions.push({ Name: '-du, --db_username [db_username]', Description: 'The database username.' });
+		this.options.CommandOptions.push({ Name: '-dw, --db_password [db_password]', Description: 'The database password.' });
+		this.options.CommandOptions.push({ Name: '-dn, --db_name [db_name]', Description: 'The database name.' });
+
+		this.options.CommandOptions.push({ Name: '-sp, --schema_path [schema_path]', Description: 'Path to the Meadow extended schema JSON file.' });
+
+		this.options.CommandOptions.push({ Name: '-s, --sync_mode [sync_mode]', Description: 'The sync mode: "Initial" or "Ongoing". Default is "Initial".', DefaultValue: 'Initial' });
+
+		this.options.CommandOptions.push({ Name: '-w, --post_run_delay [post_run_delay]', Description: 'Minutes to wait after sync before exiting. Default is 0.', DefaultValue: '0' });
+
+		this.addCommand();
+	}
+
+	_resolveConfig()
+	{
+		const tmpConfig = JSON.parse(JSON.stringify(this.fable.ProgramConfiguration));
+
+		// Apply command-line overrides for Source (API)
+		if (!tmpConfig.Source)
+		{
+			tmpConfig.Source = {};
+		}
+		if (this.CommandOptions.api_server)
+		{
+			tmpConfig.Source.ServerURL = this.CommandOptions.api_server;
+		}
+		if (this.CommandOptions.api_username)
+		{
+			tmpConfig.Source.UserID = this.CommandOptions.api_username;
+		}
+		if (this.CommandOptions.api_password)
+		{
+			tmpConfig.Source.Password = this.CommandOptions.api_password;
+		}
+
+		// Apply command-line overrides for Destination (Database)
+		if (!tmpConfig.Destination)
+		{
+			tmpConfig.Destination = {};
+		}
+		if (this.CommandOptions.db_provider)
+		{
+			tmpConfig.Destination.Provider = this.CommandOptions.db_provider;
+		}
+		if (!tmpConfig.Destination.Provider)
+		{
+			tmpConfig.Destination.Provider = 'MySQL';
+		}
+
+		const tmpProvider = tmpConfig.Destination.Provider;
+		if (!tmpConfig.Destination[tmpProvider])
+		{
+			tmpConfig.Destination[tmpProvider] = {};
+		}
+		if (this.CommandOptions.db_host)
+		{
+			tmpConfig.Destination[tmpProvider].server = this.CommandOptions.db_host;
+		}
+		if (this.CommandOptions.db_port)
+		{
+			tmpConfig.Destination[tmpProvider].port = parseInt(this.CommandOptions.db_port);
+		}
+		if (this.CommandOptions.db_username)
+		{
+			tmpConfig.Destination[tmpProvider].user = this.CommandOptions.db_username;
+		}
+		if (this.CommandOptions.db_password)
+		{
+			tmpConfig.Destination[tmpProvider].password = this.CommandOptions.db_password;
+		}
+		if (this.CommandOptions.db_name)
+		{
+			tmpConfig.Destination[tmpProvider].database = this.CommandOptions.db_name;
+		}
+
+		// Schema path override
+		if (this.CommandOptions.schema_path)
+		{
+			tmpConfig.SchemaPath = this.CommandOptions.schema_path;
+		}
+
+		// Sync config
+		if (!tmpConfig.Sync)
+		{
+			tmpConfig.Sync = {};
+		}
+
+		return tmpConfig;
+	}
+
+	onRunAsync(fCallback)
+	{
+		const tmpConfig = this._resolveConfig();
+
+		// Validate required configuration
+		if (!tmpConfig.Source || !tmpConfig.Source.ServerURL)
+		{
+			this.log.error('No source API server URL configured. Set Source.ServerURL in .meadow.config.json or use --api_server.');
+			return fCallback(new Error('Missing Source.ServerURL configuration.'));
+		}
+		if (!tmpConfig.SchemaPath)
+		{
+			this.log.error('No schema path configured. Set SchemaPath in .meadow.config.json or use --schema_path.');
+			return fCallback(new Error('Missing SchemaPath configuration.'));
+		}
+
+		const tmpProvider = tmpConfig.Destination.Provider;
+		const tmpDbConfig = tmpConfig.Destination[tmpProvider];
+		if (!tmpDbConfig || !tmpDbConfig.server || !tmpDbConfig.database)
+		{
+			this.log.error(`Database configuration incomplete for provider ${tmpProvider}. Set Destination.${tmpProvider} in .meadow.config.json or use --db_host/--db_name.`);
+			return fCallback(new Error(`Missing ${tmpProvider} database configuration.`));
+		}
+
+		this.log.info(`Data Clone: ${tmpProvider} database [${tmpDbConfig.database}] from [${tmpConfig.Source.ServerURL}]`);
+
+		// Load schema
+		let tmpSchemaModel;
+		try
+		{
+			const tmpSchemaPath = libPath.resolve(tmpConfig.SchemaPath);
+			this.log.info(`Loading schema from ${tmpSchemaPath}...`);
+			tmpSchemaModel = require(tmpSchemaPath);
+		}
+		catch (pError)
+		{
+			this.log.error(`Error loading schema from ${tmpConfig.SchemaPath}: ${pError.message}`);
+			return fCallback(pError);
+		}
+
+		// Register and instantiate services
+		this.fable.serviceManager.addServiceType('MeadowCloneRestClient', libMeadowCloneRestClient);
+		this.fable.serviceManager.instantiateServiceProvider('MeadowCloneRestClient', tmpConfig.Source);
+
+		this.fable.serviceManager.addServiceType('MeadowConnectionManager', libMeadowConnectionManager);
+		this.fable.serviceManager.instantiateServiceProvider('MeadowConnectionManager', tmpConfig.Destination);
+
+		this.fable.serviceManager.addServiceType('MeadowSync', libMeadowSync);
+
+		this.fable.Utility.waterfall(
+			[
+				(fStageComplete) =>
+				{
+					// Authenticate with the source API
+					if (tmpConfig.Source.UserID && tmpConfig.Source.Password)
+					{
+						this.log.info('Authenticating with source API...');
+						this.fable.MeadowCloneRestClient.authenticate(
+							(pError, pResponse) =>
+							{
+								if (pError)
+								{
+									this.log.error('Error authenticating with source API.', pError);
+								}
+								else
+								{
+									this.log.info(`Authenticated with source API as [${tmpConfig.Source.UserID}] at [${tmpConfig.Source.ServerURL}]`);
+								}
+								return fStageComplete();
+							});
+					}
+					else
+					{
+						this.log.info('No credentials configured; skipping authentication.');
+						return fStageComplete();
+					}
+				},
+				(fStageComplete) =>
+				{
+					// Connect to database
+					this.log.info(`Connecting to ${tmpProvider}...`);
+					this.fable.MeadowConnectionManager.connect(
+						(pError, pConnectionPool) =>
+						{
+							if (pError)
+							{
+								this.log.error(`Error connecting to ${tmpProvider}: ${pError}`, pError);
+								return fStageComplete(pError);
+							}
+							return fStageComplete(null, pConnectionPool);
+						});
+				},
+				(pConnectionPool, fStageComplete) =>
+				{
+					// Construct and configure the sync service
+					const tmpSyncConfig = Object.assign(
+						{
+							ConnectionPool: pConnectionPool,
+							PageSize: tmpConfig.Sync.PageSize || 100,
+						},
+						tmpConfig.Sync);
+
+					this.fable.serviceManager.instantiateServiceProvider('MeadowSync', tmpSyncConfig, 'SyncService');
+
+					const tmpSyncMode = this.CommandOptions.sync_mode || tmpConfig.Sync.DefaultSyncMode || 'Initial';
+					switch (tmpSyncMode)
+					{
+						case 'Ongoing':
+							this.fable.MeadowSync.SyncMode = 'Ongoing';
+							break;
+						case 'Initial':
+						default:
+							this.fable.MeadowSync.SyncMode = 'Initial';
+							break;
+					}
+
+					this.log.info(`Sync mode: ${this.fable.MeadowSync.SyncMode}`);
+
+					// Load the schema
+					this.fable.MeadowSync.loadMeadowSchema(tmpSchemaModel,
+						(pLoadSchemaError) =>
+						{
+							if (pLoadSchemaError)
+							{
+								this.log.error(`Error loading schema: ${pLoadSchemaError}`, pLoadSchemaError);
+								return fStageComplete(pLoadSchemaError);
+							}
+
+							this.log.info(`${this.fable.MeadowSync.SyncEntityList.length} schema(s) loaded successfully.`);
+							return fStageComplete();
+						});
+				},
+				(fStageComplete) =>
+				{
+					// Execute the sync
+					this.fable.MeadowSync.syncAll(
+						(pSyncError) =>
+						{
+							if (pSyncError)
+							{
+								this.log.error(`Error syncing: ${pSyncError}`, pSyncError);
+								return fStageComplete(pSyncError);
+							}
+							this.log.info('Sync complete.');
+							return fStageComplete();
+						});
+				},
+			],
+			(pError) =>
+			{
+				const tmpPostRunDelay = parseInt(this.CommandOptions.post_run_delay) || 0;
+				if (tmpPostRunDelay > 0)
+				{
+					this.log.info(`Waiting ${tmpPostRunDelay} minutes before exiting...`);
+				}
+				setTimeout(() =>
+				{
+					fCallback(pError);
+					setTimeout(() =>
+					{
+						process.exit(pError ? 1 : 0);
+					}, 10000);
+				}, tmpPostRunDelay * 60 * 1000);
+			});
+	}
+}
+
+module.exports = DataClone;

package/source/services/clone/Meadow-Service-ConnectionManager.js

@@ -0,0 +1,251 @@
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const defaultConnectionManagerOptions = (
+	{
+		Provider: 'MySQL',
+
+		MySQL:
+		{
+			server: '127.0.0.1',
+			port: 3306,
+			user: 'root',
+			password: '',
+			database: 'meadow',
+			connectionLimit: 20,
+		},
+
+		MSSQL:
+		{
+			server: '127.0.0.1',
+			port: 1433,
+			user: 'sa',
+			password: '',
+			database: 'meadow',
+			ConnectionPoolLimit: 20,
+		},
+	});
+
+class MeadowConnectionManager extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		const tmpOptions = Object.assign({}, defaultConnectionManagerOptions, pOptions);
+		super(pFable, tmpOptions, pServiceHash);
+
+		this.serviceType = 'MeadowConnectionManager';
+
+		this.Provider = this.options.Provider;
+		this.ConnectionPool = false;
+		this._Connected = false;
+	}
+
+	get connected()
+	{
+		return this._Connected;
+	}
+
+	connect(fCallback)
+	{
+		switch (this.Provider)
+		{
+			case 'MySQL':
+				return this._connectMySQL(fCallback);
+			case 'MSSQL':
+				return this._connectMSSQL(fCallback);
+			default:
+				return fCallback(new Error(`Unsupported database provider: ${this.Provider}`));
+		}
+	}
+
+	_connectMySQL(fCallback)
+	{
+		try
+		{
+			const libMeadowConnectionMySQL = require('meadow-connection-mysql');
+			const tmpConfig = Object.assign({}, this.options.MySQL);
+
+			// meadow-mysql treats connectionLimit as a global setting
+			if (tmpConfig.connectionLimit && typeof(this.fable.settings.connectionLimit) !== 'number')
+			{
+				this.fable.settings.connectionLimit = tmpConfig.connectionLimit;
+			}
+
+			// Apply MySQL settings to fable settings for meadow provider
+			this.fable.settings.MySQL = tmpConfig;
+
+			this.fable.serviceManager.addServiceType('MeadowMySQLProvider', libMeadowConnectionMySQL);
+			this.fable.serviceManager.instantiateServiceProvider('MeadowMySQLProvider', tmpConfig);
+
+			this.fable.MeadowMySQLProvider.connectAsync(
+				(pError, pConnectionPool) =>
+				{
+					if (pError)
+					{
+						this.log.error(`Error connecting to MySQL: ${pError}`, pError);
+						return fCallback(pError);
+					}
+
+					this.ConnectionPool = pConnectionPool;
+					this._Connected = true;
+					this.log.info('Connected to MySQL successfully.');
+					return fCallback(null, pConnectionPool);
+				});
+		}
+		catch (pError)
+		{
+			this.log.error(`Failed to load MySQL provider. Ensure meadow-connection-mysql is installed: ${pError.message}`);
+			return fCallback(pError);
+		}
+	}
+
+	_connectMSSQL(fCallback)
+	{
+		try
+		{
+			const libMeadowConnectionMSSQL = require('meadow-connection-mssql');
+			const tmpConfig = Object.assign({}, this.options.MSSQL);
+
+			// Apply MSSQL settings to fable settings for meadow provider
+			this.fable.settings.MSSQL = tmpConfig;
+
+			this.fable.serviceManager.addServiceType('MeadowMSSQLProvider', libMeadowConnectionMSSQL);
+			this.fable.serviceManager.instantiateServiceProvider('MeadowMSSQLProvider', tmpConfig);
+
+			this.fable.MeadowMSSQLProvider.connectAsync(
+				(pError, pConnectionPool) =>
+				{
+					if (pError)
+					{
+						this.log.error(`Error connecting to MSSQL: ${pError}`, pError);
+						return fCallback(pError);
+					}
+
+					this.ConnectionPool = pConnectionPool;
+					this._Connected = true;
+					this.log.info('Connected to MSSQL successfully.');
+					return fCallback(null, pConnectionPool);
+				});
+		}
+		catch (pError)
+		{
+			this.log.error(`Failed to load MSSQL provider. Ensure meadow-connection-mssql is installed: ${pError.message}`);
+			return fCallback(pError);
+		}
+	}
+
+	createIndex(pEntitySchema, pColumn, pIsUnique, fCallback)
+	{
+		switch (this.Provider)
+		{
+			case 'MySQL':
+				return this._createMySQLIndex(pEntitySchema, pColumn, pIsUnique, fCallback);
+			case 'MSSQL':
+				return this._createMSSQLIndex(pEntitySchema, pColumn, pIsUnique, fCallback);
+			default:
+				return fCallback();
+		}
+	}
+
+	_createMySQLIndex(pEntitySchema, pColumn, pIsUnique, fCallback)
+	{
+		if (!this.ConnectionPool)
+		{
+			this.log.error(`No connection pool available; skipping index creation for ${pEntitySchema.TableName}`);
+			return fCallback();
+		}
+
+		const tmpTableName = pEntitySchema.TableName;
+
+		if (!pColumn || (typeof(pColumn) != 'object') || !pColumn.hasOwnProperty('Column') || (typeof(pColumn.Column) != 'string') || (pColumn.Column.length < 1))
+		{
+			this.log.error(`No column information passed to createIndex for ${tmpTableName}; skipping index creation`);
+			return fCallback();
+		}
+
+		const tmpColumnName = pColumn.Column;
+		const tmpIndexName = `AK_${tmpTableName}_${tmpColumnName}`;
+		const tmpIndexIsUnique = (typeof(pIsUnique) == 'boolean') ? pIsUnique : false;
+		const tmpCheckIndexSQL = `
+ SELECT COUNT(1) AS IndexCount FROM INFORMATION_SCHEMA.STATISTICS
+	WHERE
+		table_name = '${tmpTableName}'
+		AND index_name='${tmpIndexName}'
+		AND table_schema = DATABASE()
+`;
+		this.ConnectionPool.query(tmpCheckIndexSQL,
+			(pError, pResult) =>
+			{
+				if (pError)
+				{
+					this.log.error(`Error checking for existing index ${tmpIndexName} on ${tmpTableName}:`, pError);
+					return fCallback(pError);
+				}
+
+				const tmpIndexExists = pResult[0].IndexCount > 0;
+				if (tmpIndexExists)
+				{
+					this.log.info(`Index ${tmpIndexName} already exists on ${tmpTableName}; skipping creation.`);
+					return fCallback();
+				}
+
+				let tmpCreateIndexSQL = `CREATE `;
+				if (tmpIndexIsUnique)
+				{
+					tmpCreateIndexSQL += `UNIQUE `;
+				}
+				tmpCreateIndexSQL += `INDEX ${tmpIndexName} ON ${tmpTableName} (${tmpColumnName})`;
+				this.ConnectionPool.query(tmpCreateIndexSQL,
+					(pCreateIndexError) =>
+					{
+						if (pCreateIndexError && pCreateIndexError.code !== 'ER_DUP_KEYNAME')
+						{
+							this.log.error(`Error creating index ${tmpIndexName} on ${tmpTableName}:`, pCreateIndexError);
+							return fCallback(pCreateIndexError);
+						}
+						this.log.info(`Index ${tmpIndexName} created on ${tmpTableName}.`);
+						return fCallback();
+					});
+			});
+	}
+
+	_createMSSQLIndex(pEntitySchema, pColumn, pIsUnique, fCallback)
+	{
+		if (!this.ConnectionPool)
+		{
+			this.log.error(`No connection pool available; skipping index creation for ${pEntitySchema.TableName}`);
+			return fCallback();
+		}
+
+		const tmpTableName = pEntitySchema.TableName;
+
+		if (!pColumn || (typeof(pColumn) != 'object') || !pColumn.hasOwnProperty('Column') || (typeof(pColumn.Column) != 'string') || (pColumn.Column.length < 1))
+		{
+			this.log.error(`No column information passed to createIndex for ${tmpTableName}; skipping index creation`);
+			return fCallback();
+		}
+
+		const tmpColumnName = pColumn.Column;
+		const tmpIndexSQL = `
+			IF NOT EXISTS(SELECT * FROM sys.indexes WHERE name = '${tmpColumnName}' AND object_id = OBJECT_ID('${tmpTableName}'))
+			BEGIN
+				CREATE INDEX [${tmpColumnName}] ON [dbo].[${tmpTableName}] ([${tmpColumnName}])
+			END;
+		`;
+
+		this.ConnectionPool.query(tmpIndexSQL)
+			.then(() =>
+			{
+				this.log.info(`Index ${tmpColumnName} created on ${tmpTableName}.`);
+				return fCallback();
+			})
+			.catch((pError) =>
+			{
+				this.log.error(`Error creating index for ${tmpTableName}: ${pError.message}`, { Error: pError });
+				return fCallback();
+			});
+	}
+}
+
+module.exports = MeadowConnectionManager;
+
+module.exports.default_configuration = defaultConnectionManagerOptions;