meadow-connection-sqlite 1.0.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Steven Velozo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# Meadow Connection SQLite
+
+A SQLite database connection provider for the Meadow ORM. Wraps [better-sqlite3](https://github.com/WiseLibs/better-sqlite3) as a Fable service, providing file-based database connections with WAL journal mode and DDL generation from Meadow table schemas.
+
+[![Build Status](https://github.com/stevenvelozo/meadow-connection-sqlite/workflows/Meadow-Connection-SQLite/badge.svg)](https://github.com/stevenvelozo/meadow-connection-sqlite/actions)
+[![npm version](https://badge.fury.io/js/meadow-connection-sqlite.svg)](https://badge.fury.io/js/meadow-connection-sqlite)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Features
+
+- **Better-SQLite3 Wrapper** - Synchronous, high-performance SQLite access via [better-sqlite3](https://github.com/WiseLibs/better-sqlite3)
+- **Fable Service Provider** - Registers with a Fable instance for dependency injection, logging, and configuration
+- **WAL Journal Mode** - Automatically enables Write-Ahead Logging for performance on connect
+- **Schema-Driven DDL** - Generates `CREATE TABLE` statements from Meadow table schemas with support for ID, GUID, ForeignKey, Numeric, Decimal, String, Text, DateTime, and Boolean column types
+- **Connection Safety** - Guards against double-connect and missing file path errors with descriptive logging
+- **Direct Database Access** - Exposes the underlying `better-sqlite3` database instance via `db` getter
+
+## Installation
+
+```bash
+npm install meadow-connection-sqlite
+```
+
+## Quick Start
+
+```javascript
+const libFable = require('fable');
+const MeadowConnectionSQLite = require('meadow-connection-sqlite');
+
+let fable = new libFable(
+{
+	SQLite:
+	{
+		SQLiteFilePath: './my-database.sqlite'
+	}
+});
+
+let connection = fable.instantiateServiceProvider('MeadowConnectionSQLite',
+	{}, MeadowConnectionSQLite);
+
+connection.connectAsync((pError, pDatabase) =>
+{
+	if (pError)
+	{
+		console.error('Connection failed:', pError);
+		return;
+	}
+
+	// Use the better-sqlite3 database directly
+	let stmt = connection.db.prepare('SELECT * FROM Users WHERE id = ?');
+	let user = stmt.get(42);
+});
+```
+
+## Configuration
+
+The SQLite file path can be provided through Fable settings or the service provider options:
+
+### Via Fable Settings
+
+```javascript
+let fable = new libFable(
+{
+	SQLite:
+	{
+		SQLiteFilePath: './data/app.sqlite'
+	}
+});
+```
+
+### Via Provider Options
+
+```javascript
+let connection = fable.instantiateServiceProvider('MeadowConnectionSQLite',
+{
+	SQLiteFilePath: './data/app.sqlite'
+}, MeadowConnectionSQLite);
+```
+
+Any additional options are passed through to the `better-sqlite3` constructor.
+
+## API
+
+### `connectAsync(fCallback)`
+
+Open the SQLite database file and enable WAL journal mode.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `fCallback` | `Function` | Callback receiving `(error, database)` |
+
+### `connect()`
+
+Synchronous convenience wrapper for `connectAsync` (no callback, logs a warning).
+
+### `db` (getter)
+
+Returns the underlying `better-sqlite3` database instance for direct query access.
+
+### `SQLite` (getter)
+
+Returns the `better-sqlite3` library module.
+
+### `connected` (property)
+
+Boolean indicating whether the database connection is open.
+
+### `generateCreateTableStatement(pMeadowTableSchema)`
+
+Generate a `CREATE TABLE` SQL statement from a Meadow table schema object.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pMeadowTableSchema` | `Object` | Meadow table schema with `TableName` and `Columns` array |
+
+### `createTable(pMeadowTableSchema, fCallback)`
+
+Execute a `CREATE TABLE` statement against the connected database.
+
+### `createTables(pMeadowSchema, fCallback)`
+
+Create all tables defined in a Meadow schema object (iterates `pMeadowSchema.Tables` sequentially).
+
+### `generateDropTableStatement(pTableName)`
+
+Generate a `DROP TABLE IF EXISTS` SQL statement for the given table name.
+
+## Column Type Mapping
+
+| 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 ''` |
+| `Text` | `TEXT` |
+| `DateTime` | `DATETIME` |
+| `Boolean` | `TINYINT DEFAULT 0` |
+
+## Part of the Retold Framework
+
+Meadow Connection SQLite is a database connector for the Meadow data access layer:
+
+- [meadow](https://github.com/stevenvelozo/meadow) - ORM and data access framework
+- [foxhound](https://github.com/stevenvelozo/foxhound) - Query DSL used by Meadow
+- [stricture](https://github.com/stevenvelozo/stricture) - Schema definition tool
+- [meadow-endpoints](https://github.com/stevenvelozo/meadow-endpoints) - RESTful endpoint generation
+- [fable](https://github.com/stevenvelozo/fable) - Application services framework
+
+## Testing
+
+Run the test suite:
+
+```bash
+npm test
+```
+
+Run with coverage:
+
+```bash
+npm run coverage
+```
+
+## License
+
+MIT - See [LICENSE](LICENSE) for details.
+
+## Author
+
+Steven Velozo - [steven@velozo.com](mailto:steven@velozo.com)

package/debug/Harness.js

@@ -0,0 +1,139 @@
+/*
+	Exercise the create table functionality of the SQLite provider
+*/
+/**
+* @author <steven@velozo.com>
+*/
+
+const libFable = require('fable');
+let _Fable = new libFable(
+	{
+		"Product": "MeadowSQLiteTestBookstore",
+		"ProductVersion": "1.0.0",
+
+		"UUID":
+			{
+				"DataCenter": 0,
+				"Worker": 0
+			},
+		"LogStreams":
+			[
+				{
+					"streamtype": "console"
+				}
+			],
+
+		"SQLite":
+			{
+				"server": "127.0.0.1",
+				"port": 3306,
+				"user": "sa",
+				"password": "1234567890abc.",
+				"database": "bookstore",
+				"ConnectionPoolLimit": 20
+			}
+	});
+
+_Fable.log.info("Application is starting up...");
+
+const libMeadowConnectionSQLite = require('../source/Meadow-Connection-SQLite.js');
+_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider', 
+	{
+		// This makes the sync service still able to sync IDs.
+		AllowIdentityInsert: true
+	});
+
+_Fable.log.info("...Creating SQL Connection pools at " + _Fable.settings.SQLite.server + "...");
+
+_Fable.MeadowSQLiteProvider.connectAsync(
+    (pError, pConnectionPool) =>
+    {
+        if (pError)
+        {
+            _Fable.log.error(`Error connecting to MS SQL Database: ${pError}`);
+            return false;
+        }
+
+		const tmpTestModel = require('../retold-harness/model/json_schema/BookStore-Extended.json');
+
+        _Fable.log.info('Connection complete!');
+        _Fable.MeadowSQLiteProvider.createTables(tmpTestModel,
+            (pCreateTablesError) =>
+            {
+                _Fable.log.info('Tables created successfully');
+            });
+	});
+
+
+// const libFable = require('fable');
+// const libMeadowConnectionSQLite = require('../source/Meadow-Connection-SQLite.js');
+
+// let tmpTestModel = require('../retold-harness/model/json_schema/BookStore-Extended.json');
+
+// let _Fable = new libFable(
+// 	{
+// 		"Product": "MeadowSQLiteTestBookstore",
+// 		"ProductVersion": "1.0.0",
+
+// 		"UUID":
+// 			{
+// 				"DataCenter": 0,
+// 				"Worker": 0
+// 			},
+// 		"LogStreams":
+// 			[
+// 				{
+// 					"streamtype": "console"
+// 				}
+// 			],
+
+// 		"SQLite":
+// 			{
+// 				"server": "127.0.0.1",
+// 				"port": 3306,
+// 				"user": "sa",
+// 				"password": "1234567890abc.",
+// 				"database": "bookstore",
+// 				"ConnectionPoolLimit": 20
+// 			}
+// 	});
+
+// _Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+
+// _Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+// _Fable.MeadowSQLiteProvider.connectAsync(
+// 	(pError, pConnectionPool) =>
+// 	{
+// 		if (pError)
+// 		{
+// 			_Fable.log.error(`Error connecting to MS SQL Database: ${pError}`);
+// 			return false;
+// 		}
+
+// 		_Fable.log.info('Connection complete!');
+// 		_Fable.MeadowSQLiteProvider.createTables(tmpTestModel,
+// 			(pCreateTablesError) =>
+// 			{
+// 				_Fable.log.info('Tables created successfully');
+// 				let tmpPreparedStatement = _Fable.MeadowSQLiteProvider.preparedStatement;
+// 				tmpPreparedStatement.input('param', _Fable.MeadowSQLiteProvider.SQLite.Int);
+// 				tmpPreparedStatement.prepare('SELECT * FROM Book WHERE IDBook < @param',
+// 					(pPrepareError) =>
+// 					{
+// 						tmpPreparedStatement.execute({ param: 12345 },
+// 							(pPreparedExecutionError, pPreparedResult) =>
+// 							{
+// 								_Fable.log.info(`Prepared statement returned...`, pPreparedResult);
+// 								// release the connection after queries are executed
+// 								tmpPreparedStatement.unprepare(
+// 									(pPreparedStatementUnprepareError) =>
+// 									{
+// 										_Fable.log.trace(`Prepared statement unprepared.`);
+// 									});
+// 							})
+// 					});
+// 			});
+// 	}
+// );

package/debug/Pipeline-Test.js

@@ -0,0 +1,143 @@
+/*
+	Full pipeline test for meadow-connection-sqlite:
+	Connect → Create Table → Insert → Read → Update → Delete → Transactions → Close
+*/
+const libFable = require('fable');
+const libMeadowConnectionSQLite = require('../source/Meadow-Connection-SQLite.js');
+const libFS = require('fs');
+
+// Clean up any leftover test database
+const DB_PATH = './dist/PipelineTest.db';
+if (libFS.existsSync(DB_PATH))
+{
+	libFS.unlinkSync(DB_PATH);
+}
+
+let _Fable = new libFable(
+	{
+		"Product": "MeadowSQLitePipelineTest",
+		"ProductVersion": "1.0.0",
+		"UUID": { "DataCenter": 0, "Worker": 0 },
+		"LogStreams": [{ "streamtype": "console" }],
+		"SQLite": { "SQLiteFilePath": DB_PATH }
+	});
+
+// 1. Register and instantiate the provider
+_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+_Fable.log.info('--- Step 1: Connect ---');
+_Fable.MeadowSQLiteProvider.connectAsync(
+	(pError, pDatabase) =>
+	{
+		if (pError)
+		{
+			_Fable.log.error(`Connection failed: ${pError}`);
+			process.exit(1);
+		}
+		_Fable.log.info(`Connected: ${_Fable.MeadowSQLiteProvider.connected}`);
+
+		let tmpDB = _Fable.MeadowSQLiteProvider.db;
+
+		// 2. Create a table using SQLite-compatible SQL
+		_Fable.log.info('--- Step 2: Create Table ---');
+		tmpDB.exec(`
+			CREATE TABLE IF NOT EXISTS Book (
+				IDBook INTEGER PRIMARY KEY AUTOINCREMENT,
+				GUIDBook TEXT DEFAULT '00000000-0000-0000-0000-000000000000',
+				Title TEXT DEFAULT '',
+				Author TEXT DEFAULT '',
+				YearPublished INTEGER DEFAULT 0,
+				Price REAL DEFAULT 0.0,
+				CreateDate TEXT DEFAULT (datetime('now')),
+				UpdateDate TEXT DEFAULT (datetime('now'))
+			)
+		`);
+		_Fable.log.info('Table "Book" created.');
+
+		// 3. Insert rows
+		_Fable.log.info('--- Step 3: Insert ---');
+		let tmpInsert = tmpDB.prepare(
+			`INSERT INTO Book (GUIDBook, Title, Author, YearPublished, Price) VALUES (?, ?, ?, ?, ?)`
+		);
+
+		let tmpResult1 = tmpInsert.run(_Fable.fable.getUUID(), 'The Hobbit', 'J.R.R. Tolkien', 1937, 12.99);
+		_Fable.log.info(`Inserted IDBook=${tmpResult1.lastInsertRowid}`);
+
+		let tmpResult2 = tmpInsert.run(_Fable.fable.getUUID(), 'Dune', 'Frank Herbert', 1965, 14.99);
+		_Fable.log.info(`Inserted IDBook=${tmpResult2.lastInsertRowid}`);
+
+		let tmpResult3 = tmpInsert.run(_Fable.fable.getUUID(), 'Neuromancer', 'William Gibson', 1984, 11.50);
+		_Fable.log.info(`Inserted IDBook=${tmpResult3.lastInsertRowid}`);
+
+		// 4. Read all rows
+		_Fable.log.info('--- Step 4: Read All ---');
+		let tmpAllBooks = tmpDB.prepare(`SELECT * FROM Book`).all();
+		_Fable.log.info(`Found ${tmpAllBooks.length} books:`);
+		for (let i = 0; i < tmpAllBooks.length; i++)
+		{
+			_Fable.log.info(`  [${tmpAllBooks[i].IDBook}] "${tmpAllBooks[i].Title}" by ${tmpAllBooks[i].Author} (${tmpAllBooks[i].YearPublished}) - $${tmpAllBooks[i].Price}`);
+		}
+
+		// 5. Read single row
+		_Fable.log.info('--- Step 5: Read One ---');
+		let tmpOneBook = tmpDB.prepare(`SELECT * FROM Book WHERE IDBook = ?`).get(2);
+		_Fable.log.info(`Single book: "${tmpOneBook.Title}" by ${tmpOneBook.Author}`);
+
+		// 6. Update
+		_Fable.log.info('--- Step 6: Update ---');
+		let tmpUpdate = tmpDB.prepare(`UPDATE Book SET Price = ?, UpdateDate = datetime('now') WHERE IDBook = ?`);
+		let tmpUpdateResult = tmpUpdate.run(16.99, 2);
+		_Fable.log.info(`Updated ${tmpUpdateResult.changes} row(s) — Dune price is now $16.99`);
+
+		let tmpUpdatedBook = tmpDB.prepare(`SELECT * FROM Book WHERE IDBook = ?`).get(2);
+		_Fable.log.info(`Verified: "${tmpUpdatedBook.Title}" price = $${tmpUpdatedBook.Price}`);
+
+		// 7. Delete
+		_Fable.log.info('--- Step 7: Delete ---');
+		let tmpDelete = tmpDB.prepare(`DELETE FROM Book WHERE IDBook = ?`);
+		let tmpDeleteResult = tmpDelete.run(3);
+		_Fable.log.info(`Deleted ${tmpDeleteResult.changes} row(s) — Neuromancer removed`);
+
+		let tmpRemainingBooks = tmpDB.prepare(`SELECT * FROM Book`).all();
+		_Fable.log.info(`Remaining books: ${tmpRemainingBooks.length}`);
+
+		// 8. Transaction
+		_Fable.log.info('--- Step 8: Transaction ---');
+		let tmpBulkInsert = tmpDB.transaction(
+			(pBooks) =>
+			{
+				let tmpBulkStmt = tmpDB.prepare(
+					`INSERT INTO Book (GUIDBook, Title, Author, YearPublished, Price) VALUES (?, ?, ?, ?, ?)`
+				);
+				for (let tmpBook of pBooks)
+				{
+					tmpBulkStmt.run(tmpBook.GUID, tmpBook.Title, tmpBook.Author, tmpBook.Year, tmpBook.Price);
+				}
+			});
+
+		tmpBulkInsert(
+			[
+				{ GUID: _Fable.fable.getUUID(), Title: 'Snow Crash', Author: 'Neal Stephenson', Year: 1992, Price: 13.99 },
+				{ GUID: _Fable.fable.getUUID(), Title: 'Hyperion', Author: 'Dan Simmons', Year: 1989, Price: 15.50 },
+				{ GUID: _Fable.fable.getUUID(), Title: 'Foundation', Author: 'Isaac Asimov', Year: 1951, Price: 10.99 }
+			]);
+		_Fable.log.info('Bulk insert (3 books) committed in a single transaction.');
+
+		let tmpFinalBooks = tmpDB.prepare(`SELECT * FROM Book ORDER BY IDBook`).all();
+		_Fable.log.info(`Final book count: ${tmpFinalBooks.length}`);
+		for (let i = 0; i < tmpFinalBooks.length; i++)
+		{
+			_Fable.log.info(`  [${tmpFinalBooks[i].IDBook}] "${tmpFinalBooks[i].Title}" by ${tmpFinalBooks[i].Author} ($${tmpFinalBooks[i].Price})`);
+		}
+
+		// 9. Aggregate query
+		_Fable.log.info('--- Step 9: Aggregates ---');
+		let tmpStats = tmpDB.prepare(`SELECT COUNT(*) as BookCount, AVG(Price) as AvgPrice, SUM(Price) as TotalValue FROM Book`).get();
+		_Fable.log.info(`Books: ${tmpStats.BookCount}, Average price: $${tmpStats.AvgPrice.toFixed(2)}, Total value: $${tmpStats.TotalValue.toFixed(2)}`);
+
+		// 10. Close
+		_Fable.log.info('--- Step 10: Close ---');
+		tmpDB.close();
+		_Fable.log.info('Database closed. Pipeline test complete!');
+	});

package/docs/README.md

@@ -0,0 +1,153 @@
+# Meadow Connection SQLite
+
+A Fable service provider that connects applications to SQLite databases. Wraps [better-sqlite3](https://github.com/WiseLibs/better-sqlite3) and integrates with the Meadow data layer through Fable's dependency injection system.
+
+SQLite databases are single files that require no server process. This makes them ideal for local development, embedded applications, desktop tools, CLI utilities, test suites, and any scenario where a full MySQL or MSSQL server is unnecessary overhead.
+
+## Install
+
+```bash
+npm install meadow-connection-sqlite
+```
+
+Requires Node.js. The `better-sqlite3` dependency compiles a native addon at install time — a C compiler toolchain must be available on the host.
+
+## Quick Start
+
+### 1. Configure Fable
+
+Add an `SQLite` section to your Fable configuration with the path to the database file. The file is created automatically if it does not exist:
+
+```javascript
+const libFable = require('fable');
+
+let _Fable = new libFable(
+	{
+		"Product": "MyApp",
+		"SQLite":
+		{
+			"SQLiteFilePath": "./data/myapp.db"
+		}
+	});
+```
+
+### 2. Register the Service
+
+```javascript
+const libMeadowConnectionSQLite = require('meadow-connection-sqlite');
+
+_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+```
+
+After instantiation the provider is available at `_Fable.MeadowSQLiteProvider`.
+
+### 3. Connect
+
+```javascript
+_Fable.MeadowSQLiteProvider.connectAsync(
+	(pError, pDatabase) =>
+	{
+		if (pError)
+		{
+			_Fable.log.error(`Connection failed: ${pError}`);
+			return;
+		}
+
+		// Connection is ready — WAL journaling is enabled automatically
+		_Fable.log.info('SQLite connected!');
+	});
+```
+
+### 4. Query
+
+Access the better-sqlite3 `Database` instance through the `db` getter:
+
+```javascript
+let tmpDB = _Fable.MeadowSQLiteProvider.db;
+
+// Create a table
+tmpDB.exec(`
+	CREATE TABLE IF NOT EXISTS Book (
+		IDBook INTEGER PRIMARY KEY AUTOINCREMENT,
+		Title TEXT DEFAULT '',
+		Author TEXT DEFAULT ''
+	)
+`);
+
+// Insert a row
+let tmpResult = tmpDB.prepare('INSERT INTO Book (Title, Author) VALUES (?, ?)').run('Dune', 'Frank Herbert');
+console.log(`Inserted IDBook = ${tmpResult.lastInsertRowid}`);
+
+// Query rows
+let tmpBooks = tmpDB.prepare('SELECT * FROM Book').all();
+console.log(tmpBooks);
+```
+
+## Configuration
+
+The provider reads `SQLiteFilePath` from two sources, in order of priority:
+
+1. **Constructor options** — passed as the second argument to `instantiateServiceProvider()`
+2. **Fable settings** — `fable.settings.SQLite.SQLiteFilePath`
+
+| Setting | Type | Description |
+|---------|------|-------------|
+| `SQLiteFilePath` | string | Path to the database file. Use `:memory:` for an ephemeral in-memory database. |
+
+Any additional properties in the options object are passed through to the `better-sqlite3` constructor (e.g. `readonly`, `fileMustExist`, `timeout`).
+
+### In-Memory Databases
+
+Pass `:memory:` as the file path for a database that exists only in RAM. This is useful for fast test suites:
+
+```javascript
+let _Fable = new libFable(
+	{
+		"Product": "TestSuite",
+		"SQLite": { "SQLiteFilePath": ":memory:" }
+	});
+```
+
+## How It Works
+
+```
+┌─────────────────────────────┐
+│  Fable Application          │
+│                             │
+│  fable.settings.SQLite      │
+│   └── SQLiteFilePath        │
+└───────────┬─────────────────┘
+            │ connectAsync()
+            ▼
+┌─────────────────────────────┐
+│  MeadowConnectionSQLite     │
+│  (Fable Service Provider)   │
+│                             │
+│  .connected                 │
+│  .db ──────────────────┐    │
+│  .SQLite               │    │
+└────────────────────────┼────┘
+                         │
+            ┌────────────▼────────────┐
+            │  better-sqlite3         │
+            │                         │
+            │  .prepare(sql).run()    │
+            │  .prepare(sql).get()    │
+            │  .prepare(sql).all()    │
+            │  .exec(sql)             │
+            │  .transaction(fn)       │
+            │  .pragma(str)           │
+            └─────────────────────────┘
+```
+
+The provider manages the connection lifecycle and exposes the raw `better-sqlite3` `Database` object. All queries go through better-sqlite3's synchronous API — there are no promises or callbacks for individual statements.
+
+## Companion Modules
+
+| Module | Purpose |
+|--------|---------|
+| [Meadow](/meadow/meadow/) | ORM and data access layer |
+| [FoxHound](/meadow/foxhound/) | Query DSL and SQL generation |
+| [meadow-connection-mysql](/meadow/meadow-connection-mysql/) | MySQL connection provider |
+| [meadow-connection-mssql](/meadow/meadow-connection-mssql/) | MSSQL connection provider |

package/docs/_sidebar.md

@@ -0,0 +1,20 @@
+- Getting Started
+
+  - [Overview](README.md)
+
+- Reference
+
+  - [API Reference](api.md)
+
+- Examples
+
+  - [Full Pipeline](examples-pipeline.md)
+
+- Retold Ecosystem
+
+  - [Meadow](/meadow/meadow/)
+  - [FoxHound](/meadow/foxhound/)
+  - [MySQL Connector](/meadow/meadow-connection-mysql/)
+  - [MSSQL Connector](/meadow/meadow-connection-mssql/)
+  - [Fable](/fable/fable/)
+  - [Indoctrinate](/utility/indoctrinate/)

package/docs/_topbar.md

@@ -0,0 +1,5 @@
+# Meadow Connection SQLite
+
+- [Overview](README.md)
+- [API Reference](api.md)
+- [GitHub](https://github.com/stevenvelozo/meadow-connection-sqlite)