meadow 2.0.17 → 2.0.20

package/CONTRIBUTING.md

@@ -0,0 +1,50 @@
+# Contributing to Retold
+
+We welcome contributions to Retold and its modules. This guide covers the expectations and process for contributing.
+
+## Code of Conduct
+
+The Retold community values **empathy**, **equity**, **kindness**, and **thoughtfulness**. We expect all participants to treat each other with respect, assume good intent, and engage constructively. These values apply to all interactions: pull requests, issues, discussions, and code review.
+
+## How to Contribute
+
+### Pull Requests
+
+Pull requests are the preferred method for contributing changes. To submit one:
+
+1. Fork the module repository you want to change
+2. Create a branch for your work
+3. Make your changes, following the code style of the module you are editing
+4. Ensure your changes have test coverage (see below)
+5. Open a pull request against the module's main branch
+
+**Submitting a pull request does not guarantee it will be accepted.** Maintainers review contributions for fit, quality, and alignment with the project's direction. A PR may be declined, or you may be asked to revise it. This is normal and not a reflection on the quality of your effort.
+
+### Reporting Issues
+
+If you find a bug or have a feature suggestion, open an issue on the relevant module's repository. Include enough detail to reproduce the problem or understand the proposal.
+
+## Test Coverage
+
+Every commit must include test coverage for the changes it introduces. Retold modules use Mocha in TDD style. Before submitting:
+
+- **Write tests** for any new functionality or bug fixes
+- **Run the existing test suite** with `npm test` and confirm all tests pass
+- **Check coverage** with `npm run coverage` if the module supports it
+
+Pull requests that break existing tests or lack coverage for new code will not be merged.
+
+## Code Style
+
+Follow the conventions of the module you are working in. The general Retold style is:
+
+- **Tabs** for indentation, never spaces
+- **Plain JavaScript** only (no TypeScript)
+- **Allman-style braces** (opening brace on its own line)
+- **Variable naming:** `pVariable` for parameters, `tmpVariable` for temporaries, `libSomething` for imports
+
+When in doubt, match what the surrounding code does.
+
+## Repository Structure
+
+Each module is its own git repository. The [retold](https://github.com/stevenvelozo/retold) repository tracks module organization but does not contain module source code. Direct your pull request to the specific module repository where your change belongs.

package/README.md

@@ -1,153 +1,219 @@
-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
-```
+## 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) - Auto-generated REST endpoints
+- [fable](https://github.com/stevenvelozo/fable) - Application services framework
+
+## License
 
-3. Go to http://localhost:12342/ in a web browser
+MIT
 
-4. The password is "retold"
+## Contributing
 
-5. Right now you (may) need to delete the `node_modules` folders and regenerate it for Linux.
+Pull requests are welcome. For details on our code of conduct, contribution process, and testing requirements, see the [Retold Contributing Guide](https://github.com/stevenvelozo/retold/blob/main/docs/contributing.md).

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