meadow-connection-mongodb 1.0.1 → 1.0.2

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "meadow-connection-mongodb",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Meadow MongoDB Connection Plugin",
   "main": "source/Meadow-Connection-MongoDB.js",
   "scripts": {
     "coverage": "npx quack coverage",
-    "test": "npx quack test"
+    "test": "npx quack test",
+    "docker-mongodb-start": "bash ./scripts/mongodb-test-db.sh start",
+    "docker-mongodb-stop": "bash ./scripts/mongodb-test-db.sh stop",
+    "docker-mongodb-status": "bash ./scripts/mongodb-test-db.sh status",
+    "test-docker": "bash ./scripts/mongodb-test-db.sh start && npm test"
   },
   "mocha": {
     "diff": true,
@@ -15,7 +19,7 @@
     "package": "./package.json",
     "reporter": "spec",
     "slow": "75",
-    "timeout": "5000",
+    "timeout": "10000",
     "ui": "tdd",
     "watch-files": [
       "source/**/*.js",

package/scripts/mongodb-test-db.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# MongoDB Test Database Management Script for meadow-connection-mongodb
+#
+# Usage:
+#   ./scripts/mongodb-test-db.sh start   - Start MongoDB container and wait for readiness
+#   ./scripts/mongodb-test-db.sh stop    - Stop and remove the container
+#   ./scripts/mongodb-test-db.sh status  - Check if the container is running
+#
+# The container settings match the test configuration in
+# test/MongoDB_tests.js:
+#   Host: 127.0.0.1, Port: 27117, Database: meadow_conn_test
+
+CONTAINER_NAME="meadow-conn-mongodb-test"
+MONGODB_PORT="27117"
+MONGODB_IMAGE="mongo:7"
+
+start_mongodb() {
+	# Check if container already exists
+	if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+			echo "MongoDB test container is already running."
+			return 0
+		else
+			echo "Removing stopped container..."
+			docker rm "${CONTAINER_NAME}" > /dev/null 2>&1
+		fi
+	fi
+
+	echo "Starting MongoDB test container..."
+	docker run -d \
+		--name "${CONTAINER_NAME}" \
+		-p "${MONGODB_PORT}:27017" \
+		"${MONGODB_IMAGE}"
+
+	if [ $? -ne 0 ]; then
+		echo "ERROR: Failed to start MongoDB container."
+		exit 1
+	fi
+
+	echo "Waiting for MongoDB to be ready..."
+	RETRIES=30
+	until docker exec "${CONTAINER_NAME}" mongosh --eval "db.adminCommand('ping')" > /dev/null 2>&1; do
+		RETRIES=$((RETRIES - 1))
+		if [ $RETRIES -le 0 ]; then
+			echo "ERROR: MongoDB failed to become ready in time."
+			docker logs "${CONTAINER_NAME}" 2>&1 | tail -20
+			exit 1
+		fi
+		echo "  ...waiting (${RETRIES} retries left)"
+		sleep 2
+	done
+
+	echo ""
+	echo "MongoDB test database is ready!"
+	echo "  Container: ${CONTAINER_NAME}"
+	echo "  Host:      127.0.0.1:${MONGODB_PORT}"
+	echo "  Database:  meadow_conn_test"
+	echo ""
+	echo "Run tests with: npm test"
+}
+
+stop_mongodb() {
+	if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "Stopping and removing MongoDB test container..."
+		docker stop "${CONTAINER_NAME}" > /dev/null 2>&1
+		docker rm "${CONTAINER_NAME}" > /dev/null 2>&1
+		echo "MongoDB test container removed."
+	else
+		echo "No MongoDB test container found."
+	fi
+}
+
+status_mongodb() {
+	if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "MongoDB test container is running."
+		docker ps --filter "name=${CONTAINER_NAME}" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+	elif docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "MongoDB test container exists but is stopped."
+	else
+		echo "MongoDB test container is not running."
+	fi
+}
+
+case "${1}" in
+	start)
+		start_mongodb
+		;;
+	stop)
+		stop_mongodb
+		;;
+	status)
+		status_mongodb
+		;;
+	*)
+		echo "Usage: $0 {start|stop|status}"
+		exit 1
+		;;
+esac

package/source/Meadow-Connection-MongoDB.js

@@ -6,6 +6,8 @@ const libFableServiceProviderBase = require('fable-serviceproviderbase');
 
 const { MongoClient } = require('mongodb');
 
+const libMeadowSchemaMongoDB = require('./Meadow-Schema-MongoDB.js');
+
 class MeadowConnectionMongoDB extends libFableServiceProviderBase
 {
 	constructor(pFable, pManifest, pServiceHash)
@@ -66,12 +68,20 @@ class MeadowConnectionMongoDB extends libFableServiceProviderBase
 		this._Database = false;
 		this.connected = false;
 
+		// Schema provider handles DDL operations (create, drop, index, etc.)
+		this._SchemaProvider = new libMeadowSchemaMongoDB(this.fable, this.options, `${this.Hash}-Schema`);
+
 		if (this.options.MeadowConnectionMongoDBAutoConnect)
 		{
 			this.connect();
 		}
 	}
 
+	get schemaProvider()
+	{
+		return this._SchemaProvider;
+	}
+
 	/**
 	* Build the MongoDB connection URI from options.
 	*/
@@ -96,136 +106,22 @@ class MeadowConnectionMongoDB extends libFableServiceProviderBase
 
 	generateDropTableStatement(pTableName)
 	{
-		// Returns a descriptor; the actual drop uses the MongoDB driver
-		return { operation: 'drop', collection: pTableName };
+		return this._SchemaProvider.generateDropTableStatement(pTableName);
 	}
 
 	generateCreateTableStatement(pMeadowTableSchema)
 	{
-		this.log.info(`--> Building the collection creation descriptor for ${pMeadowTableSchema.TableName} ...`);
-
-		let tmpDescriptor = {
-			operation: 'createCollection',
-			collection: pMeadowTableSchema.TableName,
-			indexes: []
-		};
-
-		for (let j = 0; j < pMeadowTableSchema.Columns.length; j++)
-		{
-			let tmpColumn = pMeadowTableSchema.Columns[j];
-
-			switch (tmpColumn.DataType)
-			{
-				case 'ID':
-					// AutoIdentity field gets a unique ascending index
-					tmpDescriptor.indexes.push(
-					{
-						key: { [tmpColumn.Column]: 1 },
-						unique: true,
-						name: `idx_${tmpColumn.Column}_unique`
-					});
-					break;
-				case 'GUID':
-					// GUID field gets a unique index
-					tmpDescriptor.indexes.push(
-					{
-						key: { [tmpColumn.Column]: 1 },
-						unique: true,
-						name: `idx_${tmpColumn.Column}_unique`
-					});
-					break;
-				case 'ForeignKey':
-					// Foreign key gets an index for lookups
-					tmpDescriptor.indexes.push(
-					{
-						key: { [tmpColumn.Column]: 1 },
-						name: `idx_${tmpColumn.Column}`
-					});
-					break;
-				default:
-					break;
-			}
-		}
-
-		return tmpDescriptor;
+		return this._SchemaProvider.generateCreateTableStatement(pMeadowTableSchema);
 	}
 
 	createTables(pMeadowSchema, fCallback)
 	{
-		this.fable.Utility.eachLimit(pMeadowSchema.Tables, 1,
-			(pTable, fCreateComplete) =>
-			{
-				return this.createTable(pTable, fCreateComplete);
-			},
-			(pCreateError) =>
-			{
-				if (pCreateError)
-				{
-					this.log.error(`Meadow-MongoDB Error creating collections from Schema: ${pCreateError}`, pCreateError);
-				}
-				this.log.info('Done creating collections!');
-				return fCallback(pCreateError);
-			});
+		return this._SchemaProvider.createTables(pMeadowSchema, fCallback);
 	}
 
 	createTable(pMeadowTableSchema, fCallback)
 	{
-		let tmpDescriptor = this.generateCreateTableStatement(pMeadowTableSchema);
-
-		if (!this._Database)
-		{
-			this.log.error(`Meadow-MongoDB CREATE COLLECTION ${tmpDescriptor.collection} failed: not connected.`);
-			return fCallback(new Error('Not connected to MongoDB'));
-		}
-
-		// Create collection (ignore error if it already exists)
-		this._Database.createCollection(tmpDescriptor.collection)
-			.then(() =>
-			{
-				this.log.info(`Meadow-MongoDB collection ${tmpDescriptor.collection} created or already exists.`);
-
-				// Create indexes if any
-				if (tmpDescriptor.indexes.length > 0)
-				{
-					let tmpCollection = this._Database.collection(tmpDescriptor.collection);
-					return tmpCollection.createIndexes(tmpDescriptor.indexes);
-				}
-			})
-			.then(() =>
-			{
-				this.log.info(`Meadow-MongoDB indexes for ${tmpDescriptor.collection} created successfully.`);
-				return fCallback();
-			})
-			.catch((pError) =>
-			{
-				// 48 = NamespaceExists (collection already exists)
-				if (pError.code === 48)
-				{
-					this.log.warn(`Meadow-MongoDB collection ${tmpDescriptor.collection} already existed.`);
-
-					// Still try to create indexes
-					if (tmpDescriptor.indexes.length > 0)
-					{
-						let tmpCollection = this._Database.collection(tmpDescriptor.collection);
-						tmpCollection.createIndexes(tmpDescriptor.indexes)
-							.then(() => fCallback())
-							.catch((pIndexError) =>
-							{
-								this.log.warn(`Meadow-MongoDB index creation for ${tmpDescriptor.collection}: ${pIndexError.message}`);
-								return fCallback();
-							});
-					}
-					else
-					{
-						return fCallback();
-					}
-				}
-				else
-				{
-					this.log.error(`Meadow-MongoDB CREATE COLLECTION ${tmpDescriptor.collection} failed!`, pError);
-					return fCallback(pError);
-				}
-			});
+		return this._SchemaProvider.createTable(pMeadowTableSchema, fCallback);
 	}
 
 	connect()
@@ -248,6 +144,7 @@ class MeadowConnectionMongoDB extends libFableServiceProviderBase
 		this._Client = new MongoClient(tmpURI, tmpOptions);
 		this._Database = this._Client.db(this.options.MongoDB.database);
 		this.connected = true;
+		this._SchemaProvider.setDatabase(this._Database);
 	}
 
 	connectAsync(fCallback)

package/source/Meadow-Schema-MongoDB.js

@@ -0,0 +1,170 @@
+/**
+* Meadow MongoDB Schema Provider
+*
+* Handles collection creation, dropping, and schema generation for MongoDB.
+* Separated from the connection provider to allow independent extension
+* for indexing and other schema operations.
+*
+* @author Steven Velozo <steven@velozo.com>
+*/
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+class MeadowSchemaMongoDB extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'MeadowSchemaMongoDB';
+
+		// Reference to the MongoDB database instance, set by the connection provider
+		this._Database = false;
+	}
+
+	/**
+	 * Set the database reference for executing schema operations.
+	 * @param {object} pDatabase - MongoDB Db instance
+	 * @returns {MeadowSchemaMongoDB} this (for chaining)
+	 */
+	setDatabase(pDatabase)
+	{
+		this._Database = pDatabase;
+		return this;
+	}
+
+	generateDropTableStatement(pTableName)
+	{
+		// Returns a descriptor; the actual drop uses the MongoDB driver
+		return { operation: 'drop', collection: pTableName };
+	}
+
+	generateCreateTableStatement(pMeadowTableSchema)
+	{
+		this.log.info(`--> Building the collection creation descriptor for ${pMeadowTableSchema.TableName} ...`);
+
+		let tmpDescriptor = {
+			operation: 'createCollection',
+			collection: pMeadowTableSchema.TableName,
+			indexes: []
+		};
+
+		for (let j = 0; j < pMeadowTableSchema.Columns.length; j++)
+		{
+			let tmpColumn = pMeadowTableSchema.Columns[j];
+
+			switch (tmpColumn.DataType)
+			{
+				case 'ID':
+					// AutoIdentity field gets a unique ascending index
+					tmpDescriptor.indexes.push(
+					{
+						key: { [tmpColumn.Column]: 1 },
+						unique: true,
+						name: `idx_${tmpColumn.Column}_unique`
+					});
+					break;
+				case 'GUID':
+					// GUID field gets a unique index
+					tmpDescriptor.indexes.push(
+					{
+						key: { [tmpColumn.Column]: 1 },
+						unique: true,
+						name: `idx_${tmpColumn.Column}_unique`
+					});
+					break;
+				case 'ForeignKey':
+					// Foreign key gets an index for lookups
+					tmpDescriptor.indexes.push(
+					{
+						key: { [tmpColumn.Column]: 1 },
+						name: `idx_${tmpColumn.Column}`
+					});
+					break;
+				default:
+					break;
+			}
+		}
+
+		return tmpDescriptor;
+	}
+
+	createTables(pMeadowSchema, fCallback)
+	{
+		this.fable.Utility.eachLimit(pMeadowSchema.Tables, 1,
+			(pTable, fCreateComplete) =>
+			{
+				return this.createTable(pTable, fCreateComplete);
+			},
+			(pCreateError) =>
+			{
+				if (pCreateError)
+				{
+					this.log.error(`Meadow-MongoDB Error creating collections from Schema: ${pCreateError}`, pCreateError);
+				}
+				this.log.info('Done creating collections!');
+				return fCallback(pCreateError);
+			});
+	}
+
+	createTable(pMeadowTableSchema, fCallback)
+	{
+		let tmpDescriptor = this.generateCreateTableStatement(pMeadowTableSchema);
+
+		if (!this._Database)
+		{
+			this.log.error(`Meadow-MongoDB CREATE COLLECTION ${tmpDescriptor.collection} failed: not connected.`);
+			return fCallback(new Error('Not connected to MongoDB'));
+		}
+
+		// Create collection (ignore error if it already exists)
+		this._Database.createCollection(tmpDescriptor.collection)
+			.then(() =>
+			{
+				this.log.info(`Meadow-MongoDB collection ${tmpDescriptor.collection} created or already exists.`);
+
+				// Create indexes if any
+				if (tmpDescriptor.indexes.length > 0)
+				{
+					let tmpCollection = this._Database.collection(tmpDescriptor.collection);
+					return tmpCollection.createIndexes(tmpDescriptor.indexes);
+				}
+			})
+			.then(() =>
+			{
+				this.log.info(`Meadow-MongoDB indexes for ${tmpDescriptor.collection} created successfully.`);
+				return fCallback();
+			})
+			.catch((pError) =>
+			{
+				// 48 = NamespaceExists (collection already exists)
+				if (pError.code === 48)
+				{
+					this.log.warn(`Meadow-MongoDB collection ${tmpDescriptor.collection} already existed.`);
+
+					// Still try to create indexes
+					if (tmpDescriptor.indexes.length > 0)
+					{
+						let tmpCollection = this._Database.collection(tmpDescriptor.collection);
+						tmpCollection.createIndexes(tmpDescriptor.indexes)
+							.then(() => fCallback())
+							.catch((pIndexError) =>
+							{
+								this.log.warn(`Meadow-MongoDB index creation for ${tmpDescriptor.collection}: ${pIndexError.message}`);
+								return fCallback();
+							});
+					}
+					else
+					{
+						return fCallback();
+					}
+				}
+				else
+				{
+					this.log.error(`Meadow-MongoDB CREATE COLLECTION ${tmpDescriptor.collection} failed!`, pError);
+					return fCallback(pError);
+				}
+			});
+	}
+}
+
+module.exports = MeadowSchemaMongoDB;

package/test/MongoDB_tests.js

@@ -32,14 +32,40 @@ const _FableConfig = (
 		"MongoDB":
 			{
 				"Server": "127.0.0.1",
-				"Port": 27017,
+				"Port": 27117,
 				"User": "",
 				"Password": "",
-				"Database": "testdb",
+				"Database": "meadow_conn_test",
 				"ConnectionPoolLimit": 20
 			}
 	});
 
+const _AnimalSchema = {
+	TableName: 'Animal',
+	Columns: [
+		{ Column: 'IDAnimal', DataType: 'ID' },
+		{ Column: 'GUIDAnimal', DataType: 'GUID', Size: 36 },
+		{ Column: 'Name', DataType: 'String', Size: 128 },
+		{ Column: 'Age', DataType: 'Numeric' },
+		{ Column: 'Cost', DataType: 'Decimal', Size: '10,2' },
+		{ Column: 'Description', DataType: 'Text' },
+		{ Column: 'Birthday', DataType: 'DateTime' },
+		{ Column: 'Active', DataType: 'Boolean' },
+		{ Column: 'IDFarm', DataType: 'ForeignKey' }
+	]
+};
+
+const _VehicleSchema = {
+	TableName: 'Vehicle',
+	Columns: [
+		{ Column: 'IDVehicle', DataType: 'ID' },
+		{ Column: 'GUIDVehicle', DataType: 'GUID', Size: 36 },
+		{ Column: 'Make', DataType: 'String', Size: 64 },
+		{ Column: 'Model', DataType: 'String', Size: 64 },
+		{ Column: 'Year', DataType: 'Numeric' }
+	]
+};
+
 suite
 (
 	'Meadow-Connection-MongoDB',
@@ -96,22 +122,7 @@ suite
 						_Fable.serviceManager.addServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
 						_Fable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider');
 
-						let tmpSchema = {
-							TableName: 'Animal',
-							Columns: [
-								{ Column: 'IDAnimal', DataType: 'ID' },
-								{ Column: 'GUIDAnimal', DataType: 'GUID', Size: 36 },
-								{ Column: 'Name', DataType: 'String', Size: 128 },
-								{ Column: 'Age', DataType: 'Numeric' },
-								{ Column: 'Cost', DataType: 'Decimal', Size: '10,2' },
-								{ Column: 'Description', DataType: 'Text' },
-								{ Column: 'Birthday', DataType: 'DateTime' },
-								{ Column: 'Active', DataType: 'Boolean' },
-								{ Column: 'IDFarm', DataType: 'ForeignKey' }
-							]
-						};
-
-						let tmpResult = _Fable.MeadowMongoDBProvider.generateCreateTableStatement(tmpSchema);
+						let tmpResult = _Fable.MeadowMongoDBProvider.generateCreateTableStatement(_AnimalSchema);
 						Expect(tmpResult.operation).to.equal('createCollection');
 						Expect(tmpResult.collection).to.equal('Animal');
 						Expect(tmpResult.indexes).to.be.an('array');
@@ -152,7 +163,7 @@ suite
 						_Fable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider');
 
 						let tmpURI = _Fable.MeadowMongoDBProvider._buildConnectionURI();
-						Expect(tmpURI).to.equal('mongodb://127.0.0.1:27017/testdb');
+						Expect(tmpURI).to.equal('mongodb://127.0.0.1:27117/meadow_conn_test');
 					}
 				);
 				test
@@ -180,5 +191,440 @@ suite
 				);
 			}
 		);
+		suite
+		(
+			'Connection',
+			() =>
+			{
+				test
+				(
+					'connect with default fable.settings',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider');
+
+						Expect(_Fable.MeadowMongoDBProvider.connected).to.equal(false);
+
+						_Fable.MeadowMongoDBProvider.connect();
+
+						Expect(_Fable.MeadowMongoDBProvider.connected).to.equal(true);
+						Expect(_Fable.MeadowMongoDBProvider.pool).to.be.an('object');
+
+						// Verify we can actually communicate with MongoDB
+						_Fable.MeadowMongoDBProvider.pool.admin().ping()
+							.then((pResult) =>
+							{
+								Expect(pResult).to.have.property('ok');
+								Expect(pResult.ok).to.equal(1);
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone();
+							})
+							.catch((pError) =>
+							{
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone(pError);
+							});
+					}
+				);
+				test
+				(
+					'connectAsync callback',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider');
+
+						_Fable.MeadowMongoDBProvider.connectAsync(
+							(pError, pDatabase) =>
+							{
+								Expect(pError).to.equal(null);
+								Expect(pDatabase).to.be.an('object');
+								Expect(_Fable.MeadowMongoDBProvider.connected).to.equal(true);
+								Expect(_Fable.MeadowMongoDBProvider.pool).to.equal(pDatabase);
+
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone();
+							});
+					}
+				);
+				test
+				(
+					'autoconnect via MeadowConnectionMongoDBAutoConnect',
+					(fDone) =>
+					{
+						let tmpConfig = JSON.parse(JSON.stringify(_FableConfig));
+						tmpConfig.MeadowConnectionMongoDBAutoConnect = true;
+
+						let _Fable = new libFable(tmpConfig);
+						_Fable.serviceManager.addAndInstantiateServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
+
+						Expect(_Fable.MeadowMongoDBProvider.connected).to.equal(true);
+						Expect(_Fable.MeadowMongoDBProvider.pool).to.be.an('object');
+
+						_Fable.MeadowMongoDBProvider.pool.admin().ping()
+							.then((pResult) =>
+							{
+								Expect(pResult.ok).to.equal(1);
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone();
+							})
+							.catch((pError) =>
+							{
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone(pError);
+							});
+					}
+				);
+				test
+				(
+					'connect when already connected logs error and does not throw',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider');
+
+						_Fable.MeadowMongoDBProvider.connect();
+						Expect(_Fable.MeadowMongoDBProvider.connected).to.equal(true);
+
+						// Second connect should not throw
+						_Fable.MeadowMongoDBProvider.connect();
+						Expect(_Fable.MeadowMongoDBProvider.connected).to.equal(true);
+
+						_Fable.MeadowMongoDBProvider.client.close();
+						return fDone();
+					}
+				);
+				test
+				(
+					'pass in your own settings and connect',
+					(fDone) =>
+					{
+						let _Fable = new libFable();
+						_Fable.serviceManager.addServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider', {MongoDB: _FableConfig.MongoDB});
+
+						_Fable.MeadowMongoDBProvider.connect();
+
+						Expect(_Fable.MeadowMongoDBProvider.connected).to.equal(true);
+
+						_Fable.MeadowMongoDBProvider.pool.admin().ping()
+							.then((pResult) =>
+							{
+								Expect(pResult.ok).to.equal(1);
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone();
+							})
+							.catch((pError) =>
+							{
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone(pError);
+							});
+					}
+				);
+			}
+		);
+		suite
+		(
+			'Collection & Index Creation',
+			() =>
+			{
+				let _Fable = null;
+
+				suiteSetup
+				(
+					(fDone) =>
+					{
+						_Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider');
+						_Fable.MeadowMongoDBProvider.connect();
+
+						// Drop any leftover test collections
+						let tmpDb = _Fable.MeadowMongoDBProvider.pool;
+						Promise.all([
+							tmpDb.collection('Animal').drop().catch(() => {}),
+							tmpDb.collection('Vehicle').drop().catch(() => {})
+						])
+						.then(() => fDone())
+						.catch(() => fDone());
+					}
+				);
+
+				suiteTeardown
+				(
+					(fDone) =>
+					{
+						let tmpDb = _Fable.MeadowMongoDBProvider.pool;
+						Promise.all([
+							tmpDb.collection('Animal').drop().catch(() => {}),
+							tmpDb.collection('Vehicle').drop().catch(() => {})
+						])
+						.then(() =>
+						{
+							_Fable.MeadowMongoDBProvider.client.close();
+							fDone();
+						})
+						.catch(() =>
+						{
+							_Fable.MeadowMongoDBProvider.client.close();
+							fDone();
+						});
+					}
+				);
+
+				test
+				(
+					'createTable creates collection and indexes',
+					(fDone) =>
+					{
+						_Fable.MeadowMongoDBProvider.createTable(_AnimalSchema,
+							(pError) =>
+							{
+								Expect(pError).to.not.be.an('error');
+
+								let tmpDb = _Fable.MeadowMongoDBProvider.pool;
+
+								// Verify collection exists
+								tmpDb.listCollections({ name: 'Animal' }).toArray()
+									.then((pCollections) =>
+									{
+										Expect(pCollections.length).to.equal(1);
+										Expect(pCollections[0].name).to.equal('Animal');
+
+										// Verify indexes were created
+										return tmpDb.collection('Animal').indexes();
+									})
+									.then((pIndexes) =>
+									{
+										// _id (default) + IDAnimal + GUIDAnimal + IDFarm = 4
+										Expect(pIndexes.length).to.equal(4);
+
+										// Find our custom indexes
+										let tmpIdAnimalIdx = pIndexes.find((pIdx) => pIdx.name === 'idx_IDAnimal_unique');
+										Expect(tmpIdAnimalIdx).to.be.an('object');
+										Expect(tmpIdAnimalIdx.unique).to.equal(true);
+
+										let tmpGuidIdx = pIndexes.find((pIdx) => pIdx.name === 'idx_GUIDAnimal_unique');
+										Expect(tmpGuidIdx).to.be.an('object');
+										Expect(tmpGuidIdx.unique).to.equal(true);
+
+										let tmpForeignKeyIdx = pIndexes.find((pIdx) => pIdx.name === 'idx_IDFarm');
+										Expect(tmpForeignKeyIdx).to.be.an('object');
+
+										return fDone();
+									})
+									.catch((pError) => fDone(pError));
+							});
+					}
+				);
+				test
+				(
+					'createTable is idempotent',
+					(fDone) =>
+					{
+						// Call createTable again for the same schema — should not error
+						_Fable.MeadowMongoDBProvider.createTable(_AnimalSchema,
+							(pError) =>
+							{
+								Expect(pError).to.not.be.an('error');
+								return fDone();
+							});
+					}
+				);
+				test
+				(
+					'createTables creates multiple collections',
+					(fDone) =>
+					{
+						let tmpMultiSchema = {
+							Tables: [_AnimalSchema, _VehicleSchema]
+						};
+
+						_Fable.MeadowMongoDBProvider.createTables(tmpMultiSchema,
+							(pError) =>
+							{
+								Expect(pError).to.not.be.an('error');
+
+								let tmpDb = _Fable.MeadowMongoDBProvider.pool;
+								tmpDb.listCollections().toArray()
+									.then((pCollections) =>
+									{
+										let tmpNames = pCollections.map((pC) => pC.name);
+										Expect(tmpNames).to.include('Animal');
+										Expect(tmpNames).to.include('Vehicle');
+										return fDone();
+									})
+									.catch((pError) => fDone(pError));
+							});
+					}
+				);
+				test
+				(
+					'createTable when not connected returns error',
+					(fDone) =>
+					{
+						// Create a disconnected provider (no connect() call)
+						let tmpFable = new libFable(_FableConfig);
+						tmpFable.serviceManager.addServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
+						tmpFable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider');
+
+						tmpFable.MeadowMongoDBProvider.createTable(_AnimalSchema,
+							(pError) =>
+							{
+								Expect(pError).to.be.an('error');
+								Expect(pError.message).to.contain('Not connected');
+								return fDone();
+							});
+					}
+				);
+			}
+		);
+		suite
+		(
+			'Raw MongoDB Operations',
+			() =>
+			{
+				let _Fable = null;
+
+				suiteSetup
+				(
+					(fDone) =>
+					{
+						_Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowMongoDBProvider', libMeadowConnectionMongoDB);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowMongoDBProvider');
+						_Fable.MeadowMongoDBProvider.connect();
+
+						// Set up a clean test collection with indexes
+						let tmpDb = _Fable.MeadowMongoDBProvider.pool;
+						tmpDb.collection('RawTestAnimal').drop()
+							.catch(() => {})
+							.then(() =>
+							{
+								return tmpDb.createCollection('RawTestAnimal');
+							})
+							.then(() =>
+							{
+								return fDone();
+							})
+							.catch((pError) => fDone(pError));
+					}
+				);
+
+				suiteTeardown
+				(
+					(fDone) =>
+					{
+						let tmpDb = _Fable.MeadowMongoDBProvider.pool;
+						tmpDb.collection('RawTestAnimal').drop()
+							.catch(() => {})
+							.then(() =>
+							{
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone();
+							})
+							.catch(() =>
+							{
+								_Fable.MeadowMongoDBProvider.client.close();
+								return fDone();
+							});
+					}
+				);
+
+				test
+				(
+					'insert and find documents',
+					(fDone) =>
+					{
+						let tmpCollection = _Fable.MeadowMongoDBProvider.pool.collection('RawTestAnimal');
+
+						tmpCollection.insertMany([
+							{ IDAnimal: 1, Name: 'Fido', Type: 'Dog' },
+							{ IDAnimal: 2, Name: 'Whiskers', Type: 'Cat' },
+							{ IDAnimal: 3, Name: 'Polly', Type: 'Parrot' }
+						])
+						.then(() =>
+						{
+							return tmpCollection.find({}).sort({ IDAnimal: 1 }).toArray();
+						})
+						.then((pDocs) =>
+						{
+							Expect(pDocs).to.be.an('array');
+							Expect(pDocs.length).to.equal(3);
+							Expect(pDocs[0].Name).to.equal('Fido');
+							Expect(pDocs[1].Name).to.equal('Whiskers');
+							Expect(pDocs[2].Name).to.equal('Polly');
+							return fDone();
+						})
+						.catch((pError) => fDone(pError));
+					}
+				);
+				test
+				(
+					'update a document',
+					(fDone) =>
+					{
+						let tmpCollection = _Fable.MeadowMongoDBProvider.pool.collection('RawTestAnimal');
+
+						tmpCollection.updateOne(
+							{ IDAnimal: 1 },
+							{ $set: { Name: 'Rex' } }
+						)
+						.then((pResult) =>
+						{
+							Expect(pResult.modifiedCount).to.equal(1);
+							return tmpCollection.findOne({ IDAnimal: 1 });
+						})
+						.then((pDoc) =>
+						{
+							Expect(pDoc.Name).to.equal('Rex');
+							return fDone();
+						})
+						.catch((pError) => fDone(pError));
+					}
+				);
+				test
+				(
+					'delete a document',
+					(fDone) =>
+					{
+						let tmpCollection = _Fable.MeadowMongoDBProvider.pool.collection('RawTestAnimal');
+
+						tmpCollection.deleteOne({ IDAnimal: 3 })
+							.then((pResult) =>
+							{
+								Expect(pResult.deletedCount).to.equal(1);
+								return tmpCollection.countDocuments();
+							})
+							.then((pCount) =>
+							{
+								Expect(pCount).to.equal(2);
+								return fDone();
+							})
+							.catch((pError) => fDone(pError));
+					}
+				);
+				test
+				(
+					'count documents with filter',
+					(fDone) =>
+					{
+						let tmpCollection = _Fable.MeadowMongoDBProvider.pool.collection('RawTestAnimal');
+
+						tmpCollection.countDocuments({ Type: 'Dog' })
+							.then((pCount) =>
+							{
+								Expect(pCount).to.equal(1);
+								return fDone();
+							})
+							.catch((pError) => fDone(pError));
+					}
+				);
+			}
+		);
 	}
 );