meadow-connection-sqlite 1.0.10

package/docs/retold-catalog.json

@@ -0,0 +1,24 @@
+{
+	"Generated": "2026-02-15T22:10:52.774Z",
+	"GitHubOrg": "stevenvelozo",
+	"DefaultBranch": "master",
+	"Groups": [
+		{
+			"Name": "Dist",
+			"Key": "dist",
+			"Description": "",
+			"Modules": [
+				{
+					"Name": "indoctrinate_content_staging",
+					"Repo": "indoctrinate_content_staging",
+					"Group": "dist",
+					"Branch": "master",
+					"HasDocs": false,
+					"HasCover": false,
+					"Sidebar": [],
+					"DocFiles": []
+				}
+			]
+		}
+	]
+}

package/docs/retold-keyword-index.json

@@ -0,0 +1,19 @@
+{
+	"Generated": "2026-02-15T22:10:52.851Z",
+	"DocumentCount": 0,
+	"LunrIndex": {
+		"version": "2.3.9",
+		"fields": [
+			"title",
+			"module",
+			"group",
+			"body"
+		],
+		"fieldVectors": [],
+		"invertedIndex": [],
+		"pipeline": [
+			"stemmer"
+		]
+	},
+	"Documents": {}
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "meadow-connection-sqlite",
+    "version": "1.0.10",
+    "description": "Meadow SQLite Plugin",
+    "main": "source/Meadow-Connection-SQLite.js",
+    "scripts": {
+        "start": "node source/Meadow-Connection-SQLite.js",
+        "build": "npx quack build",
+        "test": "npx mocha -u tdd -R spec",
+        "tests": "npx mocha -u tdd --exit -R spec --grep",
+        "coverage": "npx nyc --reporter=lcov --reporter=text-lcov npx mocha -- -u tdd -R spec"
+    },
+    "mocha": {
+        "diff": true,
+        "extension": [
+            "js"
+        ],
+        "package": "./package.json",
+        "reporter": "spec",
+        "slow": "75",
+        "timeout": "5000",
+        "ui": "tdd",
+        "watch-files": [
+            "source/**/*.js",
+            "test/**/*.js"
+        ],
+        "watch-ignore": [
+            "lib/vendor"
+        ]
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/stevenvelozo/meadow-connection-sqlite.git"
+    },
+    "keywords": [
+        "cache"
+    ],
+    "author": "Steven Velozo <steven@velozo.com> (http://velozo.com/)",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/stevenvelozo/meadow-connection-sqlite/issues"
+    },
+    "homepage": "https://github.com/stevenvelozo/meadow-connection-sqlite",
+    "devDependencies": {
+        "quackage": "^1.0.48",
+        "retold-harness": "^1.0.6"
+    },
+    "dependencies": {
+        "better-sqlite3": "^12.3.0",
+        "fable-serviceproviderbase": "^3.0.16"
+    }
+}

package/source/Meadow-Connection-SQLite.js

@@ -0,0 +1,246 @@
+/**
+* Meadow SQLite Provider Fable Service
+* @author Steven Velozo <steven@velozo.com>
+*/
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libSQLite = require('better-sqlite3');
+
+/*
+	Das alt muster:
+
+	{
+		"SQLiteFilePath": "./Meadow-SQLite-Database.sqlite"
+	}
+*/
+
+class MeadowConnectionSQLite extends libFableServiceProviderBase
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.serviceType = 'MeadowConnectionSQLite';
+
+		this.connected = false;
+		this._database = false;
+
+		if (this.fable.settings.hasOwnProperty('SQLite'))
+		{
+			if (this.fable.settings.SQLite.hasOwnProperty('SQLiteFilePath'))
+			{
+				this.options.SQLiteFilePath = this.fable.settings.SQLite.SQLiteFilePath;
+			}
+		}
+	}
+
+	generateDropTableStatement(pTableName)
+	{
+		let tmpDropTableStatement = `IF OBJECT_ID('dbo.[${pTableName}]', 'U') IS NOT NULL\n`;
+		tmpDropTableStatement += `    DROP TABLE dbo.[${pTableName}];\n`;
+		tmpDropTableStatement += `GO`;
+		return tmpDropTableStatement;
+	}
+
+	generateCreateTableStatement(pMeadowTableSchema)
+	{
+		this.log.info(`--> Building the table create string for ${pMeadowTableSchema} ...`);
+
+		let tmpPrimaryKey = false;
+		let tmpCreateTableStatement = `--   [ ${pMeadowTableSchema.TableName} ]`;
+		tmpCreateTableStatement += `\nCREATE TABLE [dbo].[${pMeadowTableSchema.TableName}]\n    (`;
+		for (let j = 0; j < pMeadowTableSchema.Columns.length; j++)
+		{
+			let tmpColumn = pMeadowTableSchema.Columns[j];
+
+			// If we aren't the first column, append a comma.
+			if (j > 0)
+			{
+				tmpCreateTableStatement += `,`;
+			}
+
+			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`;
+					//}
+					tmpPrimaryKey = tmpColumn.Column;
+					break;
+				case 'GUID':
+					tmpCreateTableStatement += `        [${tmpColumn.Column}] VARCHAR(254) DEFAULT '00000000-0000-0000-0000-000000000000'`;
+					break;
+				case 'ForeignKey':
+					tmpCreateTableStatement += `        [${tmpColumn.Column}] INT UNSIGNED NOT NULL DEFAULT 0`;
+					tmpPrimaryKey = tmpColumn.Column;
+					break;
+				case 'Numeric':
+					tmpCreateTableStatement += `        [${tmpColumn.Column}] INT NOT NULL DEFAULT 0`;
+					break;
+				case 'Decimal':
+					tmpCreateTableStatement += `        [${tmpColumn.Column}] DECIMAL(${tmpColumn.Size})`;
+					break;
+				case 'String':
+					tmpCreateTableStatement += `        [${tmpColumn.Column}] VARCHAR(${tmpColumn.Size}) DEFAULT ''`;
+					break;
+				case 'Text':
+					tmpCreateTableStatement += `        [${tmpColumn.Column}] TEXT`;
+					break;
+				case 'DateTime':
+					tmpCreateTableStatement += `        [${tmpColumn.Column}] DATETIME`;
+					break;
+				case 'Boolean':
+					tmpCreateTableStatement += `        [${tmpColumn.Column}] TINYINT DEFAULT 0`;
+					break;
+				default:
+					break;
+			}
+		}
+		if (tmpPrimaryKey)
+		{
+			//				tmpCreateTableStatement += `,\n\n        PRIMARY KEY (${tmpPrimaryKey$})`;
+		}
+		tmpCreateTableStatement += `\n    );`;
+
+		this.log.info(`Generated Create Table Statement: ${tmpCreateTableStatement}`);
+
+		return tmpCreateTableStatement;
+	}
+
+	createTables(pMeadowSchema, fCallback)
+	{
+		this.fable.Utility.eachLimit(pMeadowSchema.Tables, 1,
+			(pTable, fCreateComplete) =>
+			{
+				return this.createTable(pTable, fCreateComplete)
+			},
+			(pCreateError) =>
+			{
+				if (pCreateError)
+				{
+					this.log.error(`Meadow-SQLite Error creating tables from Schema: ${pCreateError}`,pCreateError);
+				}
+				this.log.info('Done creating tables!');
+				return fCallback(pCreateError);
+			});
+	}
+
+	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);
+				}
+			});
+	}
+
+	connect()
+	{
+		this.connectAsync();
+	}
+
+	connectAsync(fCallback)
+	{
+		let tmpCallback = fCallback;
+		if (typeof (tmpCallback) !== 'function')
+		{
+			this.log.error(`Meadow SQLite connect() called without a callback; this could lead to connection race conditions.`);
+			tmpCallback = () => { };
+		}
+
+		let tmpConnectionSettings = this.options;
+
+		if (!tmpConnectionSettings.SQLiteFilePath)
+		{
+			let tmpCleansedLogSettings = JSON.parse(JSON.stringify(tmpConnectionSettings));
+			// No leaking passwords!
+			tmpCleansedLogSettings.password = '*****************';
+			this.log.error(`Meadow-Connection-SQLite trying to connect to SQLite but the database file path is invalid; SQLiteFilePath must be in either the fable.settings.SQLite object or the connection provider constructor options.`, tmpCleansedLogSettings);
+			return tmpCallback(new Error(`Meadow-Connection-SQLite trying to connect to SQLite but the database file path is invalid.`));
+		}
+
+		if (this.connected)
+		{
+			let tmpCleansedLogSettings = JSON.parse(JSON.stringify(tmpConnectionSettings));
+			// No leaking passwords!
+			tmpCleansedLogSettings.password = '*****************';
+			this.log.error(`Meadow-Connection-SQLite trying to connect to SQLite but is already connected - skipping the second connect call.`, tmpCleansedLogSettings);
+			return tmpCallback(null, this._database);
+		}
+		else
+		{
+			try
+			{
+				this.log.info(`Meadow-Connection-SQLite connecting to file [${tmpConnectionSettings.SQLiteFilePath}].`);
+				this._database = new libSQLite(tmpConnectionSettings.SQLiteFilePath, tmpConnectionSettings);
+				// According to the documentation, setting this journal mode is very important for performance.
+				// > Though not required, [it is generally important to set the WAL pragma for performance reasons](https://github.com/WiseLibs/better-sqlite3/blob/master/docs/performance.md).
+				this._database.pragma('journal_mode = WAL');
+				this.log.info(`Meadow-Connection-SQLite successfully connected to SQLite file [${tmpConnectionSettings.SQLiteFilePath}].`);
+				this.connected = true;
+				return tmpCallback(null, this._database);
+			}
+			catch (pError)
+			{
+				this.log.error(`Meadow-Connection-SQLite error connecting to SQLite file [${tmpConnectionSettings.SQLiteFilePath}]: ${pError}`);
+				return tmpCallback(pError);
+			};
+		}
+	}
+
+	get preparedStatement()
+	{
+		if (this.connected && this._ConnectionPool)
+		{
+			return new libSQLite.PreparedStatement(this._ConnectionPool);
+		}
+		else
+		{
+			throw new Error('The Meadow Microsoft SQL provider could not create a prepared statement; disconnected or no valid connection pool.');
+		}
+	}
+
+	get SQLite()
+	{
+		return libSQLite;
+	}
+
+	get db()
+	{
+		return this._database;
+	}
+}
+
+module.exports = MeadowConnectionSQLite;

package/test/SQLite_tests.js

@@ -0,0 +1,89 @@
+/**
+* @license     MIT
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+const Chai = require('chai');
+const Expect = Chai.expect;
+const Assert = Chai.assert;
+const libFS = require('fs');
+
+const libFable = require('fable');
+const libMeadowConnectionSQLite = require('../source/Meadow-Connection-SQLite.js');
+
+const _FableConfig = (
+	{
+		"Product": "MeadowSQLiteTestBookstore",
+		"ProductVersion": "1.0.0",
+
+		"UUID":
+			{
+				"DataCenter": 0,
+				"Worker": 0
+			},
+		"LogStreams":
+			[
+				{
+					"streamtype": "console"
+				}
+			],
+
+		"SQLite":
+			{
+				"SQLiteFilePath": "./dist/FableTest.db"
+			}
+	});
+
+suite
+(
+	'Connection',
+	()=>
+	{
+		setup(
+			(fDone) =>
+			{
+				if (libFS.existsSync('./dist/FableTest.db'))
+				{
+					libFS.unlinkSync('./dist/FableTest.db');
+				}
+
+				let _Fable = new libFable(_FableConfig);
+				_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+				_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+				return fDone();
+			});
+
+		suite
+		(
+			'Connect to SQLite',
+			()=>
+			{
+				test
+				(
+					'use default settings from fable.settings',
+					(fDone) =>
+					{
+						let _Fable = new libFable(_FableConfig);
+						_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+						_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+						Expect(_Fable.MeadowSQLiteProvider).to.be.an('object');
+
+						_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');
+								return fDone();
+							}
+						);
+					}
+				);
+			}
+		);
+	}
+);