meadow-connection-sqlite 1.0.10 → 1.0.11

package/README.md

@@ -131,15 +131,15 @@ Generate a `DROP TABLE IF EXISTS` SQL statement for the given table name.
 
 | Meadow Type | SQLite Column |
 |-------------|---------------|
-| `ID` | `INT NOT NULL IDENTITY PRIMARY KEY` |
-| `GUID` | `VARCHAR(254)` with default GUID |
-| `ForeignKey` | `INT UNSIGNED NOT NULL DEFAULT 0` |
-| `Numeric` | `INT NOT NULL DEFAULT 0` |
-| `Decimal` | `DECIMAL(size)` |
-| `String` | `VARCHAR(size) DEFAULT ''` |
+| `ID` | `INTEGER PRIMARY KEY AUTOINCREMENT` |
+| `GUID` | `TEXT DEFAULT '0000...'` |
+| `ForeignKey` | `INTEGER NOT NULL DEFAULT 0` |
+| `Numeric` | `INTEGER NOT NULL DEFAULT 0` |
+| `Decimal` | `REAL` |
+| `String` | `TEXT NOT NULL DEFAULT ''` |
 | `Text` | `TEXT` |
-| `DateTime` | `DATETIME` |
-| `Boolean` | `TINYINT DEFAULT 0` |
+| `DateTime` | `TEXT` |
+| `Boolean` | `INTEGER NOT NULL DEFAULT 0` |
 
 ## Part of the Retold Framework
 

package/docs/api.md

@@ -251,6 +251,4 @@ The provider logs connection events through the Fable logging system:
 
 ## Known Limitations
 
-- **Table generation** — The `generateCreateTableStatement()` and `createTable()` methods produce MSSQL-syntax SQL that is not compatible with SQLite. Use `db.exec()` with SQLite-native `CREATE TABLE` statements instead.
-- **Prepared statement getter** — The `preparedStatement` property references an uninitialized connection pool. Use `db.prepare()` directly for prepared statements.
 - **No async queries** — better-sqlite3 is synchronous by design. For CPU-bound workloads, consider running queries in a worker thread.

package/docs/examples-pipeline.md

@@ -54,7 +54,39 @@ The database file is created automatically if it does not exist. WAL journal mod
 
 ## Step 2: Create a Table
 
-Use SQLite-native `CREATE TABLE` syntax through `db.exec()`:
+### Using createTable()
+
+Pass a Meadow table schema object to `createTable()` and it generates the correct SQLite DDL automatically:
+
+```javascript
+let tmpBookSchema =
+{
+	TableName: 'Book',
+	Columns:
+	[
+		{ Column: 'IDBook', DataType: 'ID' },
+		{ Column: 'GUIDBook', DataType: 'GUID' },
+		{ Column: 'Title', DataType: 'String', Size: '256' },
+		{ Column: 'Author', DataType: 'String', Size: '128' },
+		{ Column: 'YearPublished', DataType: 'Numeric' },
+		{ Column: 'Price', DataType: 'Decimal', Size: '10,2' },
+		{ Column: 'InPrint', DataType: 'Boolean' },
+		{ Column: 'CreateDate', DataType: 'DateTime' },
+		{ Column: 'UpdateDate', DataType: 'DateTime' }
+	]
+};
+
+_Fable.MeadowSQLiteProvider.createTable(tmpBookSchema,
+	(pError) =>
+	{
+		if (pError) { _Fable.log.error(`Create table failed: ${pError}`); return; }
+		// Table is ready for queries
+	});
+```
+
+### Using raw db.exec()
+
+For tables with custom constraints, expressions, or indexes, use `db.exec()` directly:
 
 ```javascript
 tmpDB.exec(`

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "meadow-connection-sqlite",
-    "version": "1.0.10",
+    "version": "1.0.11",
     "description": "Meadow SQLite Plugin",
     "main": "source/Meadow-Connection-SQLite.js",
     "scripts": {

package/source/Meadow-Connection-SQLite.js

@@ -36,19 +36,16 @@ class MeadowConnectionSQLite extends libFableServiceProviderBase
 
 	generateDropTableStatement(pTableName)
 	{
-		let tmpDropTableStatement = `IF OBJECT_ID('dbo.[${pTableName}]', 'U') IS NOT NULL\n`;
-		tmpDropTableStatement += `    DROP TABLE dbo.[${pTableName}];\n`;
-		tmpDropTableStatement += `GO`;
-		return tmpDropTableStatement;
+		return `DROP TABLE IF EXISTS ${pTableName};`;
 	}
 
 	generateCreateTableStatement(pMeadowTableSchema)
 	{
-		this.log.info(`--> Building the table create string for ${pMeadowTableSchema} ...`);
+		this.log.info(`--> Building the table create string for ${pMeadowTableSchema.TableName} ...`);
 
 		let tmpPrimaryKey = false;
 		let tmpCreateTableStatement = `--   [ ${pMeadowTableSchema.TableName} ]`;
-		tmpCreateTableStatement += `\nCREATE TABLE [dbo].[${pMeadowTableSchema.TableName}]\n    (`;
+		tmpCreateTableStatement += `\nCREATE TABLE IF NOT EXISTS ${pMeadowTableSchema.TableName}\n    (`;
 		for (let j = 0; j < pMeadowTableSchema.Columns.length; j++)
 		{
 			let tmpColumn = pMeadowTableSchema.Columns[j];
@@ -60,54 +57,40 @@ class MeadowConnectionSQLite extends libFableServiceProviderBase
 			}
 
 			tmpCreateTableStatement += `\n`;
-			// Dump out each column......
 			switch (tmpColumn.DataType)
 			{
 				case 'ID':
-					// if (this.options.AllowIdentityInsert)
-					// {
-					// 	tmpCreateTableStatement += `        [${tmpColumn.Column}] INT NOT NULL PRIMARY KEY`;
-					// }
-					// else
-					// {
-					// There is debate on whether IDENTITY(1,1) is better or not.
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] INT NOT NULL IDENTITY PRIMARY KEY`;
-					//}
+					tmpCreateTableStatement += `        ${tmpColumn.Column} INTEGER PRIMARY KEY AUTOINCREMENT`;
 					tmpPrimaryKey = tmpColumn.Column;
 					break;
 				case 'GUID':
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] VARCHAR(254) DEFAULT '00000000-0000-0000-0000-000000000000'`;
+					tmpCreateTableStatement += `        ${tmpColumn.Column} TEXT DEFAULT '00000000-0000-0000-0000-000000000000'`;
 					break;
 				case 'ForeignKey':
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] INT UNSIGNED NOT NULL DEFAULT 0`;
-					tmpPrimaryKey = tmpColumn.Column;
+					tmpCreateTableStatement += `        ${tmpColumn.Column} INTEGER NOT NULL DEFAULT 0`;
 					break;
 				case 'Numeric':
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] INT NOT NULL DEFAULT 0`;
+					tmpCreateTableStatement += `        ${tmpColumn.Column} INTEGER NOT NULL DEFAULT 0`;
 					break;
 				case 'Decimal':
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] DECIMAL(${tmpColumn.Size})`;
+					tmpCreateTableStatement += `        ${tmpColumn.Column} REAL`;
 					break;
 				case 'String':
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] VARCHAR(${tmpColumn.Size}) DEFAULT ''`;
+					tmpCreateTableStatement += `        ${tmpColumn.Column} TEXT NOT NULL DEFAULT ''`;
 					break;
 				case 'Text':
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] TEXT`;
+					tmpCreateTableStatement += `        ${tmpColumn.Column} TEXT`;
 					break;
 				case 'DateTime':
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] DATETIME`;
+					tmpCreateTableStatement += `        ${tmpColumn.Column} TEXT`;
 					break;
 				case 'Boolean':
-					tmpCreateTableStatement += `        [${tmpColumn.Column}] TINYINT DEFAULT 0`;
+					tmpCreateTableStatement += `        ${tmpColumn.Column} INTEGER NOT NULL DEFAULT 0`;
 					break;
 				default:
 					break;
 			}
 		}
-		if (tmpPrimaryKey)
-		{
-			//				tmpCreateTableStatement += `,\n\n        PRIMARY KEY (${tmpPrimaryKey$})`;
-		}
 		tmpCreateTableStatement += `\n    );`;
 
 		this.log.info(`Generated Create Table Statement: ${tmpCreateTableStatement}`);
@@ -136,34 +119,17 @@ class MeadowConnectionSQLite extends libFableServiceProviderBase
 	createTable(pMeadowTableSchema, fCallback)
 	{
 		let tmpCreateTableStatement = this.generateCreateTableStatement(pMeadowTableSchema);
-		this._ConnectionPool.query(tmpCreateTableStatement)
-			.then((pResult) =>
-			{
-				this.log.info(`Meadow-SQLite CREATE TABLE ${pMeadowTableSchema.TableName} Success`);
-				this.log.warn(`Meadow-SQLite Create Table Statement: ${tmpCreateTableStatement}`)
-				return fCallback();
-			})
-			.catch((pError) =>
-			{
-				if (pError.hasOwnProperty('originalError')
-					// TODO: This check may be extraneous; not familiar enough with the sqlite node driver yet
-					&& (pError.originalError.hasOwnProperty('info'))
-					// TODO: Validate that there isn't a better way to find this (pError.code isn't explicit enough)
-					&& (pError.originalError.info.message.indexOf("There is already an object named") == 0)
-					&& (pError.originalError.info.message.indexOf('in the database.') > 0))
-				{
-					// The table already existed; log a warning but keep on keeping on.
-					//this.log.warn(`Meadow-SQLite CREATE TABLE ${pMeadowTableSchema.TableName} executed but table already existed.`);
-					//this.log.warn(`Meadow-SQLite Create Table Statement: ${tmpCreateTableStatement}`)
-					return fCallback();
-				}
-				else
-				{
-					this.log.error(`Meadow-SQLite CREATE TABLE ${pMeadowTableSchema.TableName} failed!`, pError);
-					//this.log.warn(`Meadow-SQLite Create Table Statement: ${tmpCreateTableStatement}`)
-					return fCallback(pError);
-				}
-			});
+		try
+		{
+			this._database.exec(tmpCreateTableStatement);
+			this.log.info(`Meadow-SQLite CREATE TABLE ${pMeadowTableSchema.TableName} Success`);
+			return fCallback();
+		}
+		catch (pError)
+		{
+			this.log.error(`Meadow-SQLite CREATE TABLE ${pMeadowTableSchema.TableName} failed!`, pError);
+			return fCallback(pError);
+		}
 	}
 
 	connect()
@@ -222,13 +188,15 @@ class MeadowConnectionSQLite extends libFableServiceProviderBase
 
 	get preparedStatement()
 	{
-		if (this.connected && this._ConnectionPool)
+		if (this.connected && this._database)
 		{
-			return new libSQLite.PreparedStatement(this._ConnectionPool);
+			// In better-sqlite3, prepared statements are created via db.prepare(sql)
+			// This getter is maintained for API consistency with other providers.
+			return this._database;
 		}
 		else
 		{
-			throw new Error('The Meadow Microsoft SQL provider could not create a prepared statement; disconnected or no valid connection pool.');
+			throw new Error('The Meadow SQLite provider is not connected; cannot create a prepared statement.');
 		}
 	}
 

package/test/SQLite_tests.js

@@ -34,6 +34,40 @@ const _FableConfig = (
 			}
 	});
 
+// A sample Stricture-compiled Meadow table schema
+const _BookTableSchema =
+{
+	TableName: 'Book',
+	Domain: 'Default',
+	Columns:
+	[
+		{ Column: 'IDBook', DataType: 'ID' },
+		{ Column: 'GUIDBook', DataType: 'GUID' },
+		{ Column: 'Title', DataType: 'String', Size: '256' },
+		{ Column: 'Description', DataType: 'Text' },
+		{ Column: 'Price', DataType: 'Decimal', Size: '10,2' },
+		{ Column: 'PageCount', DataType: 'Numeric' },
+		{ Column: 'PublishDate', DataType: 'DateTime' },
+		{ Column: 'InPrint', DataType: 'Boolean' },
+		{ Column: 'IDAuthor', DataType: 'ForeignKey' }
+	],
+	Description: 'A table of books'
+};
+
+const _AuthorTableSchema =
+{
+	TableName: 'Author',
+	Domain: 'Default',
+	Columns:
+	[
+		{ Column: 'IDAuthor', DataType: 'ID' },
+		{ Column: 'GUIDAuthor', DataType: 'GUID' },
+		{ Column: 'Name', DataType: 'String', Size: '128' },
+		{ Column: 'Bio', DataType: 'Text' }
+	],
+	Description: 'A table of authors'
+};
+
 suite
 (
 	'Connection',
@@ -46,10 +80,10 @@ suite
 				{
 					libFS.unlinkSync('./dist/FableTest.db');
 				}
-
-				let _Fable = new libFable(_FableConfig);
-				_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
-				_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+				if (!libFS.existsSync('./dist'))
+				{
+					libFS.mkdirSync('./dist', { recursive: true });
+				}
 				return fDone();
 			});
 
@@ -72,18 +106,324 @@ suite
 						_Fable.MeadowSQLiteProvider.connectAsync(
 							(pError) =>
 							{
-								if (pError)
-								{
-									return fDone(pError);
-								}
-								let tmpRows = _Fable.MeadowSQLiteProvider.db.prepare(`SELECT * FROM FableTest`).get();
-								Expect(tmpRows).to.be.an('array');
+								Expect(pError).to.not.exist;
+								Expect(_Fable.MeadowSQLiteProvider.connected).to.equal(true);
+								Expect(_Fable.MeadowSQLiteProvider.db).to.be.an('object');
 								return fDone();
 							}
 						);
 					}
 				);
+
+				test
+				(
+					'attempt to connect twice should not error',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						_Fable.MeadowSQLiteProvider.connectAsync(
+							(pError) =>
+							{
+								Expect(pError).to.not.exist;
+								// Connect again -- should log an error but callback with the existing database
+								_Fable.MeadowSQLiteProvider.connectAsync(
+									(pSecondError, pDatabase) =>
+									{
+										// Should not be a hard error
+										Expect(pSecondError).to.not.exist;
+										Expect(pDatabase).to.be.an('object');
+										return fDone();
+									});
+							});
+					}
+				);
+
+				test
+				(
+					'connect without a callback should not throw',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						// Call connect() (sync wrapper) which calls connectAsync without a callback
+						_Fable.MeadowSQLiteProvider.connect();
+						// Give it a tick to complete
+						setTimeout(
+							() =>
+							{
+								Expect(_Fable.MeadowSQLiteProvider.connected).to.equal(true);
+								return fDone();
+							}, 100);
+					}
+				);
+
+				test
+				(
+					'fail to connect with no SQLiteFilePath',
+					(fDone) =>
+					{
+						let _Fable = new libFable(
+							{
+								Product: 'MeadowSQLiteTestNoPath',
+								ProductVersion: '1.0.0'
+							});
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						_Fable.MeadowSQLiteProvider.connectAsync(
+							(pError) =>
+							{
+								Expect(pError).to.be.an.instanceof(Error);
+								return fDone();
+							});
+					}
+				);
+			}
+		);
+
+		suite
+		(
+			'DDL Generation',
+			()=>
+			{
+				test
+				(
+					'generate a DROP TABLE statement',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						let tmpDropStatement = _Fable.MeadowSQLiteProvider.generateDropTableStatement('Book');
+						Expect(tmpDropStatement).to.equal('DROP TABLE IF EXISTS Book;');
+						return fDone();
+					}
+				);
+
+				test
+				(
+					'generate a CREATE TABLE statement from a Meadow table schema',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						_Fable.MeadowSQLiteProvider.connectAsync(
+							(pError) =>
+							{
+								Expect(pError).to.not.exist;
+								let tmpCreateStatement = _Fable.MeadowSQLiteProvider.generateCreateTableStatement(_BookTableSchema);
+
+								// Should use SQLite syntax, not MSSQL
+								Expect(tmpCreateStatement).to.contain('CREATE TABLE IF NOT EXISTS Book');
+								Expect(tmpCreateStatement).to.contain('IDBook INTEGER PRIMARY KEY AUTOINCREMENT');
+								Expect(tmpCreateStatement).to.contain('GUIDBook TEXT DEFAULT');
+								Expect(tmpCreateStatement).to.contain('Title TEXT NOT NULL DEFAULT');
+								Expect(tmpCreateStatement).to.contain('Description TEXT');
+								Expect(tmpCreateStatement).to.contain('Price REAL');
+								Expect(tmpCreateStatement).to.contain('PageCount INTEGER NOT NULL DEFAULT 0');
+								Expect(tmpCreateStatement).to.contain('PublishDate TEXT');
+								Expect(tmpCreateStatement).to.contain('InPrint INTEGER NOT NULL DEFAULT 0');
+								Expect(tmpCreateStatement).to.contain('IDAuthor INTEGER NOT NULL DEFAULT 0');
+
+								// Should NOT contain any MSSQL syntax
+								Expect(tmpCreateStatement).to.not.contain('[dbo]');
+								Expect(tmpCreateStatement).to.not.contain('IDENTITY');
+								Expect(tmpCreateStatement).to.not.contain('UNSIGNED');
+								Expect(tmpCreateStatement).to.not.contain('TINYINT');
+								Expect(tmpCreateStatement).to.not.contain('VARCHAR');
+
+								return fDone();
+							});
+					}
+				);
+			}
+		);
+
+		suite
+		(
+			'Create Tables',
+			()=>
+			{
+				test
+				(
+					'create a single table',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						_Fable.MeadowSQLiteProvider.connectAsync(
+							(pError) =>
+							{
+								Expect(pError).to.not.exist;
+
+								_Fable.MeadowSQLiteProvider.createTable(_BookTableSchema,
+									(pCreateError) =>
+									{
+										Expect(pCreateError).to.not.exist;
+
+										// Verify the table was actually created by inserting and reading back
+										let tmpDB = _Fable.MeadowSQLiteProvider.db;
+										tmpDB.prepare('INSERT INTO Book (Title, Price, PageCount, InPrint) VALUES (?, ?, ?, ?)').run('Test Book', 19.99, 200, 1);
+
+										let tmpRow = tmpDB.prepare('SELECT * FROM Book WHERE IDBook = 1').get();
+										Expect(tmpRow).to.be.an('object');
+										Expect(tmpRow.Title).to.equal('Test Book');
+										Expect(tmpRow.Price).to.equal(19.99);
+										Expect(tmpRow.PageCount).to.equal(200);
+										Expect(tmpRow.InPrint).to.equal(1);
+										Expect(tmpRow.IDAuthor).to.equal(0);
+										Expect(tmpRow.GUIDBook).to.equal('00000000-0000-0000-0000-000000000000');
+										return fDone();
+									});
+							});
+					}
+				);
+
+				test
+				(
+					'create a table that already exists (idempotent)',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						_Fable.MeadowSQLiteProvider.connectAsync(
+							(pError) =>
+							{
+								Expect(pError).to.not.exist;
+
+								// Create the table
+								_Fable.MeadowSQLiteProvider.createTable(_BookTableSchema,
+									(pCreateError) =>
+									{
+										Expect(pCreateError).to.not.exist;
+
+										// Create it again -- should not error because of IF NOT EXISTS
+										_Fable.MeadowSQLiteProvider.createTable(_BookTableSchema,
+											(pSecondCreateError) =>
+											{
+												Expect(pSecondCreateError).to.not.exist;
+												return fDone();
+											});
+									});
+							});
+					}
+				);
+
+				test
+				(
+					'create multiple tables from a schema',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						_Fable.MeadowSQLiteProvider.connectAsync(
+							(pError) =>
+							{
+								Expect(pError).to.not.exist;
+
+								let tmpSchema =
+								{
+									Tables:
+									[
+										_BookTableSchema,
+										_AuthorTableSchema
+									]
+								};
+
+								_Fable.MeadowSQLiteProvider.createTables(tmpSchema,
+									(pCreateError) =>
+									{
+										Expect(pCreateError).to.not.exist;
+
+										// Verify both tables exist
+										let tmpDB = _Fable.MeadowSQLiteProvider.db;
+
+										tmpDB.prepare('INSERT INTO Author (Name) VALUES (?)').run('Test Author');
+										let tmpAuthor = tmpDB.prepare('SELECT * FROM Author WHERE IDAuthor = 1').get();
+										Expect(tmpAuthor).to.be.an('object');
+										Expect(tmpAuthor.Name).to.equal('Test Author');
+
+										tmpDB.prepare('INSERT INTO Book (Title, IDAuthor) VALUES (?, ?)').run('Author Book', 1);
+										let tmpBook = tmpDB.prepare('SELECT * FROM Book WHERE IDBook = 1').get();
+										Expect(tmpBook).to.be.an('object');
+										Expect(tmpBook.Title).to.equal('Author Book');
+										Expect(tmpBook.IDAuthor).to.equal(1);
+
+										return fDone();
+									});
+							});
+					}
+				);
+			}
+		);
+
+		suite
+		(
+			'Accessors',
+			()=>
+			{
+				test
+				(
+					'access the SQLite library via the SQLite getter',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						Expect(_Fable.MeadowSQLiteProvider.SQLite).to.be.a('function');
+						return fDone();
+					}
+				);
+
+				test
+				(
+					'access the preparedStatement getter when connected',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						_Fable.MeadowSQLiteProvider.connectAsync(
+							(pError) =>
+							{
+								Expect(pError).to.not.exist;
+								let tmpPrepared = _Fable.MeadowSQLiteProvider.preparedStatement;
+								Expect(tmpPrepared).to.be.an('object');
+								return fDone();
+							});
+					}
+				);
+
+				test
+				(
+					'preparedStatement getter throws when disconnected',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						Expect(() => _Fable.MeadowSQLiteProvider.preparedStatement).to.throw('The Meadow SQLite provider is not connected');
+						return fDone();
+					}
+				);
 			}
 		);
 	}
-);
+);