meadow 2.0.16 → 2.0.18

package/.config/configstore/update-notifier-npm.json

@@ -1,4 +1,4 @@
 {
 	"optOut": false,
-	"lastUpdateCheck": 1699195015190
+	"lastUpdateCheck": 1761078031905
 }

package/Dockerfile_LUXURYCode

@@ -26,47 +26,6 @@ RUN ( sudo mysqld_safe --skip-grant-tables --skip-networking & ) && sleep 5 &&
 # Import the initial database
 RUN sudo service mariadb restart && sleep 5 && mysql -u root -p"123456789" -e "CREATE DATABASE FableTest;"
 
-RUN echo "...installing vscode extensions..."
-# Mocha unit testing in the sidebar
-RUN code-server --install-extension hbenl.vscode-mocha-test-adapter
-RUN code-server --install-extension hbenl.test-adapter-converter
-RUN code-server --install-extension hbenl.vscode-test-explorer
-
-# Magic indentation rainbow
-RUN code-server --install-extension oderwat.indent-rainbow
-RUN code-server --install-extension dbaeumer.vscode-eslint
-
-# Contextual git
-RUN code-server --install-extension eamodio.gitlens
-
-# Other extensions (uncomment them to have them automagic, or run this from a terminal to install in the container):
-
-# SQL Tools
-RUN code-server --install-extension mtxr.sqltools
-RUN code-server --install-extension mtxr.sqltools-driver-mysql
-
-# Microsoft's AI code completion
-# RUN code-server --install-extension  VisualStudioExptTeam.vscodeintellicode
-
-# Live server -- make sure to open up the port on the docker image
-# RUN code-server --install-extension ritwickdey.LiveServer
-
-# Quick link to required modules' documentation
-# RUN code-server --install-extension bengreenier.vscode-node-readme
-
-# Switch up fonts
-# RUN code-server --install-extension evan-buss.font-switcher
-
-# Icons
-# RUN code-server --install-extension vscode-icons-team.vscode-icons
-# RUN code-server --install-extension PKief.material-icon-theme
-
-# Hover over CSS colors to see them previewed
-# RUN code-server --install-extension bierner.color-info
-
-# An easy on the eyes color theme
-# RUN code-server --install-extension daylerees.rainglow
-
 SHELL ["/bin/bash", "-c"]
 USER coder
 
@@ -88,4 +47,4 @@ RUN . ~/.nvm/nvm.sh && source ~/.bashrc && nvm alias default 14
 
 WORKDIR /home/coder/meadow
 
-ENTRYPOINT ["/usr/bin/MySQL-Laden-Entry.sh"]
+ENTRYPOINT ["/usr/bin/MySQL-Laden-Entry.sh"]

package/README.md

@@ -1,153 +1,215 @@
-Meadow
-======
+# Meadow
 
-A Javascript Data Broker.
+> A data access layer providing magic where you want it, programmability where you don't
 
-Who doesn't love writing the same code over and over again? Good question. Anybody who doesn't probably wants something to do simple data access stuff. And some of the complicated interactions as well. Meadow aims to provide a simple “magic where you want it, programmability where you don't” pattern.
+Meadow is a JavaScript data broker that handles repetitive CRUD operations through a consistent, provider-agnostic interface. It doesn't care whether your data lives in MySQL, MSSQL, SQLite, or an in-browser IndexedDB store -- Meadow provides the schema management, query building, and data marshalling while you provide the business logic.
 
-## Install
+## Features
 
-```sh
-$ npm install meadow
+- **Provider-Agnostic Design** - Pluggable database backends through a consistent interface
+- **Schema-Driven** - Define your data model once, get validation, default objects, and audit tracking for free
+- **FoxHound Query DSL** - Fluent query builder that generates dialect-specific SQL
+- **Automatic Audit Tracking** - Auto-populated create/update/delete timestamps and user stamps
+- **Soft Deletes** - Built-in logical deletion with automatic query filtering
+- **GUID Uniqueness** - Automatic GUID generation and uniqueness enforcement on create
+- **Raw Query Overrides** - Escape hatch for custom SQL when the DSL isn't enough
+- **Fable Integration** - First-class service in the Fable ecosystem with logging and configuration
+
+## Quick Start
+
+```javascript
+const libFable = require('fable').new();
+const libMeadow = require('meadow');
+
+// Create a Meadow DAL for the "Book" entity
+const meadow = libMeadow.new(libFable, 'Book')
+	.setProvider('MySQL')
+	.setDefaultIdentifier('IDBook')
+	.setSchema([
+		{ Column: 'IDBook', Type: 'AutoIdentity' },
+		{ Column: 'GUIDBook', Type: 'AutoGUID' },
+		{ Column: 'Title', Type: 'String', Size: '255' },
+		{ Column: 'Author', Type: 'String', Size: '128' },
+		{ Column: 'CreateDate', Type: 'CreateDate' },
+		{ Column: 'CreatingIDUser', Type: 'CreateIDUser' },
+		{ Column: 'UpdateDate', Type: 'UpdateDate' },
+		{ Column: 'UpdatingIDUser', Type: 'UpdateIDUser' },
+		{ Column: 'DeleteDate', Type: 'DeleteDate' },
+		{ Column: 'DeletingIDUser', Type: 'DeleteIDUser' },
+		{ Column: 'Deleted', Type: 'Deleted' }
+	]);
+
+// Read a single record
+meadow.doRead(meadow.query.addFilter('IDBook', 42),
+	(pError, pQuery, pBook) =>
+	{
+		if (pError)
+		{
+			return console.log('Error reading book:', pError);
+		}
+		console.log('Found:', pBook.Title, 'by', pBook.Author);
+	});
 ```
 
-Because meadow requires the [fable](https://github.com/stevenvelozo/fable) library, you will also need to install that dependency:
+## Installation
 
-```sh
-$ npm install fable
+```bash
+npm install meadow
 ```
 
-## Quick Start
+## How It Works
 
-It is pretty easy to perform CRUD access on your database.  And facilities are there to go crazy with custom queries and stored procedures.
+Meadow follows the Fable service provider pattern. You create a DAL instance for each entity in your data model, configure its schema and provider, then use the CRUD methods to interact with your database. Meadow handles query generation, data marshalling, schema validation, and audit stamping automatically.
 
-```js
-// These settings are read automatically from the fable.settings object by meadow
-var databaseSettings = {
-	MySQL:
-		{
-			Server: "localhost",
-			Port: 3306,
-			User: "root",
-			Password: "",
-			Database: "sales_data",
-			ConnectionPoolLimit: 20
-		}
-};
+```
+Fable (Core)
+  └── Meadow (Data Access Layer)
+        ├── Schema (Column definitions, validation, defaults)
+        ├── FoxHound Query DSL (Dialect-specific SQL generation)
+        ├── Behaviors (Create, Read, Reads, Update, Delete, Count, Undelete)
+        └── Provider (MySQL, MSSQL, SQLite, ALASQL, MeadowEndpoints, None)
+              └── Database Connection
+```
 
-var fable = require('fable').new();
+## CRUD Operations
 
-// Create a MySQL connection pool (assuming MySQL is the provider you are using)
-var libMySQL = require('mysql2');
-fable.MeadowMySQLConnectionPool = libMySQL.createPool
-	(
-		{
-			connectionLimit: _Fable.settings.MySQL.ConnectionPoolLimit,
-			host: _Fable.settings.MySQL.Server,
-			port: _Fable.settings.MySQL.Port,
-			user: _Fable.settings.MySQL.User,
-			password: _Fable.settings.MySQL.Password,
-			database: _Fable.settings.MySQL.Database,
-			namedPlaceholders: true
-		}
-	);
+All operations follow an async waterfall pattern with a consistent callback signature.
 
+### Create
 
-// Create a new meadow DAL object for the "Customers" data set
-var meadow = require('meadow').new(fable, 'Customers')
-		.setProvider('MySQL')
-		.setDefaultIdentifier('customerID');
+```javascript
+const tmpQuery = meadow.query.addRecord({ Title: 'Dune', Author: 'Frank Herbert' });
+meadow.doCreate(tmpQuery,
+	(pError, pCreateQuery, pReadQuery, pRecord) =>
+	{
+		console.log('Created book with ID:', pRecord.IDBook);
+	});
+```
 
-// Construct a query, filtering to a specific customer, number 17
-var queryDescription = meadow.query.addFilter('customerID', 17);
+### Read
+
+```javascript
+// Single record
+meadow.doRead(meadow.query.addFilter('IDBook', 1),
+	(pError, pQuery, pRecord) =>
+	{
+		console.log('Book:', pRecord.Title);
+	});
+
+// Multiple records with pagination
+meadow.doReads(meadow.query.setCap(25).setBegin(0),
+	(pError, pQuery, pRecords) =>
+	{
+		console.log('Found', pRecords.length, 'books');
+	});
+```
 
-// Now pass the read query into the customer DAL, with a callback
-meadow.doRead(queryDescription,
-		function(error, query, customer)
-		{
-			// The customer parameter will contain a javascript object if there is:
-			//   1) a record with customerID = 17
-			//   2) in the customers table
-			//   3) in the sales_data database
-			if (error)
-			{
-				return console.log('Error querying customer data: '+error);
-			}
-			console.log('Found customer ID '+customer.customerID+' who is named '+customer.name);
-		}
-	);
+### Update
+
+```javascript
+const tmpQuery = meadow.query
+	.addFilter('IDBook', 1)
+	.addRecord({ Title: 'Updated Title' });
+meadow.doUpdate(tmpQuery,
+	(pError, pUpdateQuery, pReadQuery, pRecord) =>
+	{
+		console.log('Updated:', pRecord.Title);
+	});
 ```
 
-## You can also use the ALASQL persistence engine
+### Delete and Count
+
+```javascript
+// Delete (soft delete if schema supports it)
+meadow.doDelete(meadow.query.addFilter('IDBook', 1),
+	(pError, pQuery, pResult) =>
+	{
+		console.log('Deleted:', pResult, 'record(s)');
+	});
+
+// Count records
+meadow.doCount(meadow.query,
+	(pError, pQuery, pCount) =>
+	{
+		console.log('Total books:', pCount);
+	});
+```
 
-```js
-// These settings are read automatically from the fable.settings object by meadow
-var fable = require('fable').new();
+## Schema
 
-// Create the IndexdDB database [example], attach and use it
-var libALASQL = require('alasql');
-libALASQL('CREATE INDEXEDDB DATABASE IF NOT EXISTS example;');
-libALASQL('ATTACH INDEXEDDB DATABASE example;');
-libALASQL('USE example;');
-fable.ALASQL = libALASQL;
+Meadow schemas define your data model with special column types that enable automatic behavior:
 
+| Type | Description |
+|------|-------------|
+| `AutoIdentity` | Auto-increment primary key |
+| `AutoGUID` | Automatically generated GUID |
+| `CreateDate` / `CreateIDUser` | Auto-populated on create |
+| `UpdateDate` / `UpdateIDUser` | Auto-populated on update |
+| `DeleteDate` / `DeleteIDUser` | Auto-populated on delete |
+| `Deleted` | Soft delete flag |
+| `String`, `Text`, `Numeric`, `Decimal`, `Boolean`, `DateTime` | Standard data types |
 
+## Providers
 
-// Create a new meadow DAL object for the "Customers" data set
-var meadow = require('meadow').new(fable, 'Customers')
-		.setProvider('ALASQL')
-		.setDefaultIdentifier('customerID');
+| Provider | Description |
+|----------|-------------|
+| `MySQL` | MySQL/MariaDB via mysql2 |
+| `MSSQL` | Microsoft SQL Server with prepared statements |
+| `SQLite` | SQLite via meadow-connection-sqlite |
+| `ALASQL` | In-browser IndexedDB via ALASQL |
+| `MeadowEndpoints` | REST proxy to remote Meadow API |
+| `None` | Null provider for testing |
 
-// Construct a query, filtering to a specific customer, number 17
-var queryDescription = meadow.query.addFilter('customerID', 17);
+## ALASQL Provider Example
 
-// Now pass the read query into the customer DAL, with a callback
-meadow.doRead(queryDescription,
-		function(error, query, customer)
-		{
-			// The customer parameter will contain a javascript object if there is:
-			//   1) a record with customerID = 17
-			//   2) in the customers table
-			//   3) in the sales_data database
-			if (error)
-			{
-				return console.log('Error querying customer data: '+error);
-			}
-			console.log('Found customer ID '+customer.customerID+' who is named '+customer.name);
-		}
-	);
-```
+```javascript
+const libFable = require('fable').new();
+const libALASQL = require('alasql');
+
+libALASQL('CREATE INDEXEDDB DATABASE IF NOT EXISTS example;');
+libALASQL('ATTACH INDEXEDDB DATABASE example;');
+libALASQL('USE example;');
+libFable.ALASQL = libALASQL;
 
+const meadow = require('meadow').new(libFable, 'Customers')
+	.setProvider('ALASQL')
+	.setDefaultIdentifier('customerID');
+```
 
 ## MSSQL Docker Image
 
-To run the Microsoft SQL Server tests, you can use the free image on dockerhub.
+To run Microsoft SQL Server tests locally:
 
-```
-docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=1234567890abc." -p 14333:1433 --name meadow-mssql-test --hostname meadowsqltest -d mcr.microsoft.com/mssql/server:2022-latest
+```bash
+docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=1234567890abc." \
+  -p 14333:1433 --name meadow-mssql-test --hostname meadowsqltest \
+  -d mcr.microsoft.com/mssql/server:2022-latest
+
+docker exec meadow-mssql-test sh -c \
+  "/opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P '1234567890abc.' -Q 'CREATE DATABASE bookstore;'"
 ```
 
-Then you need to create the test database:
+## Testing
 
-```
-docker exec meadow-mssql-test sh -c "/opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P '1234567890abc.' -Q 'CREATE DATABASE bookstore;'"
+```bash
+npm test
 ```
 
-### Docker Development Environment
+## Documentation
 
+Detailed documentation is available in the `docs/` folder and can be served locally:
 
-1. Run this command to build this image:
-```
-docker build ./ -t retold/meadow:local
+```bash
+npx docsify-cli serve docs
 ```
 
-2. Run this command to build the local container:
-```
-docker run -it --name meadow-dev -p 127.0.0.1:12342:8080 -v "$PWD/.config:/home/coder/.config"  -v "$PWD:/home/coder/meadow" -u "$(id -u):$(id -g)" -e "DOCKER_USER=$USER" retold/meadow:local
-```
-
-3. Go to http://localhost:12342/ in a web browser
-
-4. The password is "retold"
+## Related Packages
 
-5. Right now you (may) need to delete the `node_modules` folders and regenerate it for Linux.
+- [foxhound](https://github.com/stevenvelozo/foxhound) - Query DSL for SQL generation
+- [stricture](https://github.com/stevenvelozo/stricture) - Schema definition language
+- [meadow-endpoints](https://github.com/stevenvelozo/meadow-endpoints) - Automatic REST endpoint generation
+- [meadow-connection-mysql](https://github.com/stevenvelozo/meadow-connection-mysql) - MySQL connection provider
+- [meadow-connection-mssql](https://github.com/stevenvelozo/meadow-connection-mssql) - MSSQL connection provider
+- [meadow-connection-sqlite](https://github.com/stevenvelozo/meadow-connection-sqlite) - SQLite connection provider
+- [fable](https://github.com/stevenvelozo/fable) - Service provider framework
+- [orator](https://github.com/stevenvelozo/orator) - API server abstraction

package/docs/README.md

@@ -0,0 +1,276 @@
+# Meadow
+
+> A data access layer providing magic where you want it, programmability where you don't
+
+Meadow is a JavaScript data broker that handles repetitive CRUD operations through a consistent, provider-agnostic interface. It doesn't care whether your data lives in MySQL, MSSQL, SQLite, or an in-browser IndexedDB store -- Meadow provides the schema management, query building, and data marshalling while you provide the business logic.
+
+## Features
+
+- **Provider-Agnostic Design** - Pluggable database backends through a consistent interface
+- **Schema-Driven** - Define your data model once, get validation, default objects, and audit tracking for free
+- **FoxHound Query DSL** - Fluent query builder that generates dialect-specific SQL
+- **Automatic Audit Tracking** - Auto-populated create/update/delete timestamps and user stamps
+- **Soft Deletes** - Built-in logical deletion with automatic query filtering
+- **GUID Uniqueness** - Automatic GUID generation and uniqueness enforcement on create
+- **Raw Query Overrides** - Escape hatch for custom SQL when the DSL isn't enough
+- **Fable Integration** - First-class service in the Fable ecosystem with logging and configuration
+
+## Quick Start
+
+```javascript
+const libFable = require('fable').new();
+const libMeadow = require('meadow');
+
+// Create a Meadow DAL for the "Book" entity
+const meadow = libMeadow.new(libFable, 'Book')
+	.setProvider('MySQL')
+	.setDefaultIdentifier('IDBook')
+	.setSchema([
+		{ Column: 'IDBook', Type: 'AutoIdentity' },
+		{ Column: 'GUIDBook', Type: 'AutoGUID' },
+		{ Column: 'Title', Type: 'String', Size: '255' },
+		{ Column: 'Author', Type: 'String', Size: '128' },
+		{ Column: 'CreateDate', Type: 'CreateDate' },
+		{ Column: 'CreatingIDUser', Type: 'CreateIDUser' },
+		{ Column: 'UpdateDate', Type: 'UpdateDate' },
+		{ Column: 'UpdatingIDUser', Type: 'UpdateIDUser' },
+		{ Column: 'DeleteDate', Type: 'DeleteDate' },
+		{ Column: 'DeletingIDUser', Type: 'DeleteIDUser' },
+		{ Column: 'Deleted', Type: 'Deleted' }
+	]);
+
+// Read a single record
+meadow.doRead(meadow.query.addFilter('IDBook', 42),
+	(pError, pQuery, pBook) =>
+	{
+		if (pError)
+		{
+			return console.log('Error reading book:', pError);
+		}
+		console.log('Found:', pBook.Title, 'by', pBook.Author);
+	});
+```
+
+## Installation
+
+```bash
+npm install meadow
+```
+
+## How It Works
+
+Meadow follows the Fable service provider pattern. You create a DAL instance for each entity in your data model, configure its schema and provider, then use the CRUD methods to interact with your database. Meadow handles query generation, data marshalling, schema validation, and audit stamping automatically.
+
+```
+Fable (Core)
+  └── Meadow (Data Access Layer)
+        ├── Schema (Column definitions, validation, defaults)
+        ├── FoxHound Query DSL (Dialect-specific SQL generation)
+        ├── Behaviors (Create, Read, Reads, Update, Delete, Count, Undelete)
+        └── Provider (MySQL, MSSQL, SQLite, ALASQL, MeadowEndpoints, None)
+              └── Database Connection
+```
+
+## CRUD Operations
+
+All operations follow an async waterfall pattern with a consistent callback signature.
+
+### Create
+
+```javascript
+const tmpQuery = meadow.query.addRecord({ Title: 'Dune', Author: 'Frank Herbert' });
+meadow.doCreate(tmpQuery,
+	(pError, pCreateQuery, pReadQuery, pRecord) =>
+	{
+		console.log('Created book with ID:', pRecord.IDBook);
+	});
+```
+
+### Read
+
+```javascript
+// Single record
+meadow.doRead(meadow.query.addFilter('IDBook', 1),
+	(pError, pQuery, pRecord) =>
+	{
+		console.log('Book:', pRecord.Title);
+	});
+
+// Multiple records
+meadow.doReads(meadow.query.setCap(25).setBegin(0),
+	(pError, pQuery, pRecords) =>
+	{
+		console.log('Found', pRecords.length, 'books');
+	});
+```
+
+### Update
+
+```javascript
+const tmpQuery = meadow.query
+	.addFilter('IDBook', 1)
+	.addRecord({ Title: 'Updated Title' });
+meadow.doUpdate(tmpQuery,
+	(pError, pUpdateQuery, pReadQuery, pRecord) =>
+	{
+		console.log('Updated:', pRecord.Title);
+	});
+```
+
+### Delete
+
+```javascript
+meadow.doDelete(meadow.query.addFilter('IDBook', 1),
+	(pError, pQuery, pResult) =>
+	{
+		console.log('Deleted:', pResult, 'record(s)');
+	});
+```
+
+### Count
+
+```javascript
+meadow.doCount(meadow.query,
+	(pError, pQuery, pCount) =>
+	{
+		console.log('Total books:', pCount);
+	});
+```
+
+## Schema
+
+Meadow schemas define your data model with special column types that enable automatic behavior.
+
+### Column Types
+
+| Type | Description |
+|------|-------------|
+| `AutoIdentity` | Auto-increment primary key |
+| `AutoGUID` | Automatically generated GUID |
+| `CreateDate` | Auto-populated timestamp on create |
+| `CreateIDUser` | Auto-populated user ID on create |
+| `UpdateDate` | Auto-populated timestamp on update |
+| `UpdateIDUser` | Auto-populated user ID on update |
+| `DeleteDate` | Auto-populated timestamp on delete |
+| `DeleteIDUser` | Auto-populated user ID on delete |
+| `Deleted` | Soft delete flag (enables logical deletion) |
+| `String` | String field with optional `Size` |
+| `Text` | Long text field |
+| `Numeric` | Integer field |
+| `Decimal` | Decimal field with `Size` as `"precision,scale"` |
+| `Boolean` | Boolean field |
+| `DateTime` | Date/time field |
+
+### JSON Schema Validation
+
+Meadow also supports JSON Schema (v4) for object validation:
+
+```javascript
+meadow.setJsonSchema({
+	title: 'Book',
+	type: 'object',
+	properties:
+	{
+		IDBook: { type: 'integer' },
+		Title: { type: 'string' },
+		Author: { type: 'string' }
+	},
+	required: ['Title']
+});
+
+const result = meadow.schemaFull.validateObject({ Title: 'Dune' });
+// { Valid: true, Errors: [] }
+```
+
+## Configuration
+
+Meadow reads database configuration from the Fable settings object:
+
+```json
+{
+	"Product": "MyApp",
+	"ProductVersion": "1.0.0",
+	"MySQL": {
+		"Server": "localhost",
+		"Port": 3306,
+		"User": "root",
+		"Password": "",
+		"Database": "myapp",
+		"ConnectionPoolLimit": 20
+	},
+	"QueryThresholdWarnTime": 200
+}
+```
+
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| `MySQL` | object | - | MySQL connection settings |
+| `QueryThresholdWarnTime` | number | `200` | Slow query warning threshold (ms) |
+| `MeadowProvider` | string | - | Default provider name |
+| `MeadowRoleNames` | array | `['Unauthenticated', 'User', 'Manager', 'Director', 'Executive', 'Administrator']` | Role name mapping |
+
+## Providers
+
+Meadow supports multiple database backends through its provider system.
+
+| Provider | Description | Connection |
+|----------|-------------|------------|
+| `MySQL` | MySQL/MariaDB via mysql2 | `fable.MeadowMySQLConnectionPool` or `fable.MeadowMySQLProvider` |
+| `MSSQL` | Microsoft SQL Server | `fable.MeadowMSSQLProvider` |
+| `SQLite` | SQLite database | Via meadow-connection-sqlite |
+| `ALASQL` | In-browser IndexedDB | `fable.ALASQL` |
+| `MeadowEndpoints` | REST proxy to remote Meadow API | Via `MeadowEndpoints` settings |
+| `None` | Null provider for testing | No connection required |
+
+## Raw Query Overrides
+
+For complex queries that exceed the DSL capabilities:
+
+```javascript
+// Set a custom query for Read operations
+meadow.rawQueries.setQuery('Read',
+	'SELECT b.*, a.Name AS AuthorName FROM Book b JOIN Author a ON b.IDAuthor = a.IDAuthor WHERE b.IDBook = :IDBook');
+
+// Load from file
+meadow.rawQueries.loadQuery('CustomReport', './queries/book-report.sql');
+
+// Check and use
+if (meadow.rawQueries.checkQuery('CustomReport'))
+{
+	const sql = meadow.rawQueries.getQuery('CustomReport');
+}
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+## Documentation
+
+- [Architecture](architecture.md) - System architecture and design patterns
+- [Schema](schema/README.md) - Column definitions, JSON Schema validation, default objects, authorization
+- [Query DSL](query-dsl.md) - FoxHound query building
+- [Query Operations](query/README.md) - Query object overview and CRUD operations
+  - [Create](query/create.md) - Insert new records
+  - [Read](query/read.md) - Retrieve single and multiple records
+  - [Update](query/update.md) - Modify existing records
+  - [Delete](query/delete.md) - Soft delete and undelete records
+  - [Count](query/count.md) - Count records matching criteria
+- [Providers](providers/README.md) - Database provider system
+  - [MySQL](providers/mysql.md) - Connection pooling, named placeholders
+  - [MSSQL](providers/mssql.md) - Prepared statements, type mapping
+  - [SQLite](providers/sqlite.md) - Embedded database
+  - [ALASQL](providers/alasql.md) - In-memory SQL, browser support
+
+## Related Packages
+
+- [foxhound](https://github.com/stevenvelozo/foxhound) - Query DSL for SQL generation
+- [stricture](https://github.com/stevenvelozo/stricture) - Schema definition language
+- [meadow-endpoints](https://github.com/stevenvelozo/meadow-endpoints) - Automatic REST endpoint generation
+- [meadow-connection-mysql](https://github.com/stevenvelozo/meadow-connection-mysql) - MySQL connection provider
+- [meadow-connection-mssql](https://github.com/stevenvelozo/meadow-connection-mssql) - MSSQL connection provider
+- [meadow-connection-sqlite](https://github.com/stevenvelozo/meadow-connection-sqlite) - SQLite connection provider
+- [fable](https://github.com/stevenvelozo/fable) - Service provider framework
+- [orator](https://github.com/stevenvelozo/orator) - API server abstraction