meadow 2.0.17 → 2.0.18

package/docs/schema/README.md

@@ -0,0 +1,408 @@
+# Schema
+
+> Define your data model once — get validation, defaults, audit tracking, and authorization for free
+
+Meadow's schema system is the foundation of every data entity. It defines column structure, validation rules, default object templates, and authorization policies in a single declarative configuration. The schema drives everything from query generation to automatic audit stamping.
+
+## Overview
+
+A Meadow schema consists of four complementary parts:
+
+```
+Schema Definition
+  ├── Column Schema (array)     → Defines columns, types, and sizes
+  ├── JSON Schema (object)      → Validates objects against JSON Schema v4
+  ├── Default Object (object)   → Template merged with new records on create
+  └── Authorizer (object)       → Role-based access control per operation
+```
+
+Each part is optional and can be set independently, but together they provide a complete data model definition.
+
+## Column Schema
+
+The column schema is an array of objects that defines the columns in your entity. Each column has a `Column` name, a `Type`, and an optional `Size`.
+
+```javascript
+const tmpSchema =
+[
+	{ Column: 'IDBook', Type: 'AutoIdentity' },
+	{ Column: 'GUIDBook', Type: 'AutoGUID' },
+	{ Column: 'Title', Type: 'String', Size: '255' },
+	{ Column: 'Author', Type: 'String', Size: '128' },
+	{ Column: 'PageCount', Type: 'Numeric' },
+	{ Column: 'Price', Type: 'Decimal', Size: '12,2' },
+	{ Column: 'InPrint', Type: 'Boolean' },
+	{ Column: 'PublishDate', Type: 'DateTime' },
+	{ Column: 'Synopsis', Type: 'Text' },
+	{ 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' }
+];
+
+meadow.setSchema(tmpSchema);
+```
+
+### Column Types
+
+| Type | Description | SQL Mapping | Default Value |
+|------|-------------|-------------|---------------|
+| `AutoIdentity` | Auto-increment primary key | `INT UNSIGNED AUTO_INCREMENT` | N/A (generated) |
+| `AutoGUID` | Automatically generated GUID | `CHAR(36)` | `'00000000-0000-0000-0000-000000000000'` |
+| `String` | Variable-length string | `VARCHAR(Size)` | `''` |
+| `Text` | Long text field | `TEXT` | `null` |
+| `Numeric` | Integer field | `INT` | `0` |
+| `Integer` | Integer field (alias) | `INT` | `0` |
+| `Decimal` | Decimal number | `DECIMAL(precision,scale)` | `0` |
+| `Boolean` | Boolean flag | `INT` / `BOOLEAN` | `0` |
+| `DateTime` | Date/time field | `DATETIME` | `null` |
+
+### Audit Column Types
+
+These special types trigger automatic behavior during CRUD operations:
+
+| Type | Description | Auto-Populated |
+|------|-------------|----------------|
+| `CreateDate` | Timestamp when record was created | Set to current UTC time on `doCreate` |
+| `CreateIDUser` | User who created the record | Set from `query.IDUser` on `doCreate` |
+| `UpdateDate` | Timestamp of last update | Set to current UTC time on `doUpdate` |
+| `UpdateIDUser` | User who last updated | Set from `query.IDUser` on `doUpdate` |
+| `DeleteDate` | Timestamp of soft deletion | Set to current UTC time on `doDelete` |
+| `DeleteIDUser` | User who soft deleted | Set from `query.IDUser` on `doDelete` |
+| `Deleted` | Soft delete flag | Set to `1` on `doDelete`, `0` on `doUndelete` |
+
+### Column Properties
+
+| Property | Required | Description |
+|----------|----------|-------------|
+| `Column` | Yes | The column name in the database |
+| `Type` | Yes | One of the column types listed above |
+| `Size` | No | For `String`: max length (e.g., `'255'`). For `Decimal`: precision and scale (e.g., `'12,2'`) |
+
+## JSON Schema Validation
+
+Meadow supports JSON Schema v4 for validating objects before they reach the database. Validation uses the [is-my-json-valid](https://github.com/mafintosh/is-my-json-valid) library with greedy mode enabled.
+
+```javascript
+meadow.setJsonSchema({
+	title: 'Book',
+	description: 'A book in the catalog',
+	type: 'object',
+	properties:
+	{
+		IDBook:
+		{
+			description: 'The unique identifier for a book',
+			type: 'integer'
+		},
+		Title:
+		{
+			description: 'The book title',
+			type: 'string'
+		},
+		Author:
+		{
+			description: 'The book author',
+			type: 'string'
+		},
+		PageCount:
+		{
+			description: 'Number of pages',
+			type: 'integer'
+		}
+	},
+	required: ['Title']
+});
+```
+
+### Validating Objects
+
+```javascript
+// Valid object
+const tmpResult = meadow.schemaFull.validateObject(
+	{ IDBook: 1, Title: 'Dune', Author: 'Frank Herbert', PageCount: 412 });
+// { Valid: true, Errors: [] }
+
+// Invalid object (missing required field)
+const tmpResult = meadow.schemaFull.validateObject(
+	{ IDBook: 2, Author: 'Isaac Asimov' });
+// { Valid: false, Errors: [...] }
+```
+
+The `validateObject` method returns an object with:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `Valid` | boolean | Whether the object passed validation |
+| `Errors` | array | Validation errors (empty when valid) |
+
+## Default Object
+
+The default object is a template that gets merged with submitted record data during `doCreate` operations. This ensures every column has a value even if the caller doesn't provide one.
+
+```javascript
+meadow.setDefault({
+	IDBook: null,
+	GUIDBook: '',
+	Title: 'Untitled',
+	Author: 'Unknown',
+	PageCount: 0,
+	Price: 0,
+	InPrint: false,
+	Synopsis: null,
+	CreateDate: false,
+	CreatingIDUser: 0,
+	UpdateDate: false,
+	UpdatingIDUser: 0,
+	Deleted: 0,
+	DeletingIDUser: 0,
+	DeleteDate: false
+});
+```
+
+### How Default Merging Works
+
+During `doCreate`, Meadow merges the default object with the submitted record:
+
+```javascript
+// Internally, Meadow does:
+// finalRecord = extend({}, defaultObject, submittedRecord)
+
+// If you create with:
+meadow.doCreate(
+	meadow.query.addRecord({ Title: 'Neuromancer', Author: 'William Gibson' }),
+	(pError, pCreateQuery, pReadQuery, pRecord) =>
+	{
+		// pRecord will contain:
+		// {
+		//   IDBook: <auto-generated>,
+		//   GUIDBook: <auto-generated>,
+		//   Title: 'Neuromancer',       ← from submitted record
+		//   Author: 'William Gibson',   ← from submitted record
+		//   PageCount: 0,               ← from default object
+		//   Price: 0,                   ← from default object
+		//   InPrint: false,             ← from default object
+		//   ...
+		// }
+	});
+```
+
+## Authorizer
+
+The authorizer defines role-based access control for each CRUD operation. Roles map to permission rules that Meadow-Endpoints uses to gate API access.
+
+```javascript
+meadow.setAuthorizer({
+	Unauthenticated:
+	{
+		Create: 'Deny',
+		Read: 'Deny',
+		Reads: 'Deny',
+		Update: 'Deny',
+		Delete: 'Deny',
+		Count: 'Deny',
+		Schema: 'Deny'
+	},
+	User:
+	{
+		Create: 'Allow',
+		Read: 'Allow',
+		Reads: 'Allow',
+		Update: 'Mine',
+		Delete: 'Mine',
+		Count: 'Allow',
+		Schema: 'Allow'
+	},
+	Administrator:
+	{
+		Create: 'Allow',
+		Read: 'Allow',
+		Reads: 'Allow',
+		Update: 'Allow',
+		Delete: 'Allow',
+		Count: 'Allow',
+		Schema: 'Allow'
+	}
+});
+```
+
+### Permission Values
+
+| Value | Description |
+|-------|-------------|
+| `'Allow'` | Full access to the operation |
+| `'Deny'` | No access to the operation |
+| Custom string | Contextual filter (e.g., `'Mine'`, `'MyCustomer'`) applied by Meadow-Endpoints behaviors |
+
+### Operations
+
+| Operation | CRUD Method | Description |
+|-----------|-------------|-------------|
+| `Create` | `doCreate` | Insert new records |
+| `Read` | `doRead` | Retrieve a single record |
+| `Reads` | `doReads` | Retrieve multiple records |
+| `ReadsBy` | `doReads` | Retrieve by alternate key |
+| `ReadMax` | `doRead` | Retrieve max value |
+| `ReadSelectList` | `doReads` | Retrieve select lists |
+| `Update` | `doUpdate` | Modify existing records |
+| `Delete` | `doDelete` | Soft delete records |
+| `Count` | `doCount` | Count records |
+| `CountBy` | `doCount` | Count by alternate key |
+| `Schema` | — | Access schema metadata |
+| `Validate` | — | Validate objects |
+| `New` | — | Generate default objects |
+
+### Default Role Names
+
+Meadow uses a default set of role names (configurable via `MeadowRoleNames` in Fable settings):
+
+```javascript
+['Unauthenticated', 'User', 'Manager', 'Director', 'Executive', 'Administrator']
+```
+
+## Loading from a Package File
+
+The most common way to define a complete schema is through a package JSON file that bundles all four parts together.
+
+### Package File Format
+
+```json
+{
+	"Scope": "Book",
+	"Domain": "Library",
+	"DefaultIdentifier": "IDBook",
+	"Schema": [
+		{ "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" }
+	],
+	"JsonSchema": {
+		"title": "Book",
+		"type": "object",
+		"properties": {
+			"IDBook": { "type": "integer" },
+			"Title": { "type": "string" },
+			"Author": { "type": "string" }
+		},
+		"required": ["Title"]
+	},
+	"DefaultObject": {
+		"IDBook": null,
+		"GUIDBook": "",
+		"Title": "Untitled",
+		"Author": "Unknown"
+	},
+	"Authorization": {
+		"Unauthenticated": { "Read": "Deny", "Create": "Deny" },
+		"User": { "Read": "Allow", "Create": "Allow" },
+		"Administrator": { "Read": "Allow", "Create": "Allow" }
+	}
+}
+```
+
+### Loading from File
+
+```javascript
+const meadow = require('meadow')
+	.new(libFable)
+	.loadFromPackage(__dirname + '/Book.json');
+```
+
+The `loadFromPackage` method reads the JSON file and calls:
+- `setScope(package.Scope)`
+- `setDefaultIdentifier(package.DefaultIdentifier)`
+- `setSchema(package.Schema)`
+- `setJsonSchema(package.JsonSchema)`
+- `setDefault(package.DefaultObject)`
+- `setAuthorizer(package.Authorization)`
+
+### Loading from Object
+
+If you already have the package definition as a JavaScript object:
+
+```javascript
+const meadow = require('meadow')
+	.new(libFable)
+	.loadFromPackageObject({
+		Scope: 'Book',
+		DefaultIdentifier: 'IDBook',
+		Schema:
+		[
+			{ Column: 'IDBook', Type: 'AutoIdentity' },
+			{ Column: 'Title', Type: 'String', Size: '255' }
+		],
+		DefaultObject:
+		{
+			IDBook: null,
+			Title: 'Untitled'
+		}
+	});
+```
+
+### Package Properties
+
+| Property | Required | Description |
+|----------|----------|-------------|
+| `Scope` | Yes | Entity name (e.g., `'Book'`) |
+| `Domain` | No | Domain grouping for organization |
+| `DefaultIdentifier` | Yes | Primary key column name (e.g., `'IDBook'`) |
+| `Schema` | Yes | Column schema array |
+| `JsonSchema` | No | JSON Schema v4 for validation |
+| `DefaultObject` | No | Default values template |
+| `Authorization` | No | Role-based access control rules |
+
+## API Reference
+
+### Meadow Schema Methods
+
+All schema methods are chainable and return the Meadow instance.
+
+| Method | Parameters | Description |
+|--------|------------|-------------|
+| `setSchema(pSchema)` | Array of column definitions | Set the column schema |
+| `setJsonSchema(pJsonSchema)` | JSON Schema v4 object | Set validation schema |
+| `setDefault(pDefault)` | Default values object | Set default object template |
+| `setAuthorizer(pAuthorizer)` | Authorization rules object | Set role-based access rules |
+| `loadFromPackage(pPath)` | File path to JSON | Load all schema parts from a file |
+| `loadFromPackageObject(pObject)` | Package object | Load all schema parts from an object |
+| `validateObject(pObject)` | Object to validate | Validate against JSON Schema |
+
+### Meadow Schema Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `schema` | array | The column definition array |
+| `schemaFull` | MeadowSchema | The full schema object with all methods |
+| `jsonSchema` | object | The JSON Schema v4 definition |
+| `defaultIdentifier` | string | The primary key column name |
+| `defaultGUIdentifier` | string | The GUID column name (derived from identifier) |
+
+## Provider Synchronization
+
+When you call `setSchema()`, Meadow automatically synchronizes the schema with the active provider. This is important for providers like ALASQL that create tables dynamically based on the schema definition.
+
+```javascript
+// Internally, Meadow calls:
+// provider.setSchema(scope, schema, defaultIdentifier, defaultGUIdentifier)
+
+// This means you can change schemas at runtime:
+meadow.setSchema(updatedSchema);
+// The provider is automatically updated
+```
+
+## Related Documentation
+
+- [Query Overview](query/README.md) — How queries interact with schema-defined columns
+- [Providers Overview](providers/README.md) — How providers use schema for SQL generation
+- [Create Operation](query/create.md) — How default objects and auto-stamps work during create

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meadow",
-  "version": "2.0.17",
+  "version": "2.0.18",
   "description": "A data access library.",
   "main": "source/Meadow.js",
   "scripts": {
@@ -11,7 +11,18 @@
     "build": "./node_modules/.bin/gulp build --full-paths",
     "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t retold/meadow:local",
     "docker-dev-run": "docker run -it -d --name meadow-dev -p 12342:8080 -p 12106:3306 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/meadow\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" retold/meadow:local",
-    "docker-dev-shell": "docker exec -it meadow-dev /bin/bash"
+    "docker-dev-shell": "docker exec -it meadow-dev /bin/bash",
+    "docker-mysql-start": "./scripts/mysql-test-db.sh start",
+    "docker-mysql-stop": "./scripts/mysql-test-db.sh stop",
+    "docker-mysql-status": "./scripts/mysql-test-db.sh status",
+    "test-mysql": "./scripts/mysql-test-db.sh start && ./node_modules/mocha/bin/_mocha -u tdd --exit -R spec --grep Meadow-Provider-MySQL",
+    "test-mysql-all": "./scripts/mysql-test-db.sh start && ./node_modules/mocha/bin/_mocha -u tdd --exit -R spec",
+    "docker-mssql-start": "./scripts/mssql-test-db.sh start",
+    "docker-mssql-stop": "./scripts/mssql-test-db.sh stop",
+    "docker-mssql-status": "./scripts/mssql-test-db.sh status",
+    "test-mssql": "./scripts/mssql-test-db.sh start && ./node_modules/mocha/bin/_mocha -u tdd --exit -R spec --grep Meadow-Provider-MSSQL",
+    "test-mssql-all": "./scripts/mssql-test-db.sh start && ./node_modules/mocha/bin/_mocha -u tdd --exit -R spec",
+    "test-all-providers": "./scripts/mysql-test-db.sh start && ./scripts/mssql-test-db.sh start && ./node_modules/mocha/bin/_mocha -u tdd --exit -R spec"
   },
   "mocha": {
     "diff": true,
@@ -47,9 +58,10 @@
   "homepage": "https://github.com/stevenvelozo/meadow",
   "devDependencies": {
     "alasql": "^4.1.10",
+    "better-sqlite3": "^12.6.2",
     "browserify": "^17.0.0",
     "chai": "4.3.10",
-    "fable": "^3.1.18",
+    "fable": "^3.1.51",
     "gulp": "^4.0.2",
     "gulp-babel": "^8.0.0",
     "gulp-sourcemaps": "^3.0.0",
@@ -57,6 +69,7 @@
     "gulp-util": "^3.0.8",
     "meadow-connection-mssql": "^1.0.9",
     "meadow-connection-mysql": "^1.0.4",
+    "meadow-connection-sqlite": "file:../meadow-connection-sqlite",
     "mocha": "10.2.0",
     "mysql2": "^3.6.3",
     "nyc": "^15.1.0",

package/scripts/mssql-test-db.sh

@@ -0,0 +1,111 @@
+#!/bin/bash
+# MSSQL Test Database Management Script
+#
+# Usage:
+#   ./scripts/mssql-test-db.sh start   - Start MSSQL container and wait for readiness
+#   ./scripts/mssql-test-db.sh stop    - Stop and remove the container
+#   ./scripts/mssql-test-db.sh status  - Check if the container is running
+#
+# The container settings match the test configuration in
+# test/Meadow-Provider-MSSQL_tests.js:
+#   Host: 127.0.0.1, Port: 14333, User: sa
+#   Password: 1234567890abc., Database: bookstore
+
+CONTAINER_NAME="meadow-mssql-test"
+SA_PASSWORD="1234567890abc."
+MSSQL_DATABASE="bookstore"
+MSSQL_PORT="14333"
+MSSQL_IMAGE="mcr.microsoft.com/mssql/server:2022-latest"
+
+start_mssql() {
+	# Check if container already exists
+	if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+			echo "MSSQL test container is already running."
+			return 0
+		else
+			echo "Removing stopped container..."
+			docker rm "${CONTAINER_NAME}" > /dev/null 2>&1
+		fi
+	fi
+
+	echo "Starting MSSQL test container..."
+	docker run -d \
+		--name "${CONTAINER_NAME}" \
+		-e ACCEPT_EULA=Y \
+		-e "MSSQL_SA_PASSWORD=${SA_PASSWORD}" \
+		-p "${MSSQL_PORT}:1433" \
+		"${MSSQL_IMAGE}"
+
+	if [ $? -ne 0 ]; then
+		echo "ERROR: Failed to start MSSQL container."
+		exit 1
+	fi
+
+	echo "Waiting for MSSQL to be ready..."
+	RETRIES=30
+	until docker exec "${CONTAINER_NAME}" /opt/mssql-tools18/bin/sqlcmd -S localhost -U sa -P "${SA_PASSWORD}" -C -Q "SELECT 1" > /dev/null 2>&1; do
+		RETRIES=$((RETRIES - 1))
+		if [ $RETRIES -le 0 ]; then
+			echo "ERROR: MSSQL failed to become ready in time."
+			docker logs "${CONTAINER_NAME}" 2>&1 | tail -20
+			exit 1
+		fi
+		echo "  ...waiting (${RETRIES} retries left)"
+		sleep 2
+	done
+
+	# Create the bookstore database
+	echo "Creating database '${MSSQL_DATABASE}'..."
+	docker exec "${CONTAINER_NAME}" /opt/mssql-tools18/bin/sqlcmd \
+		-S localhost -U sa -P "${SA_PASSWORD}" -C \
+		-Q "IF NOT EXISTS(SELECT * FROM sys.databases WHERE name = '${MSSQL_DATABASE}') BEGIN CREATE DATABASE [${MSSQL_DATABASE}] END"
+
+	echo ""
+	echo "MSSQL test database is ready!"
+	echo "  Container: ${CONTAINER_NAME}"
+	echo "  Host:      127.0.0.1:${MSSQL_PORT}"
+	echo "  User:      sa"
+	echo "  Password:  ${SA_PASSWORD}"
+	echo "  Database:  ${MSSQL_DATABASE}"
+	echo ""
+	echo "Run tests with: npm test"
+}
+
+stop_mssql() {
+	if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "Stopping and removing MSSQL test container..."
+		docker stop "${CONTAINER_NAME}" > /dev/null 2>&1
+		docker rm "${CONTAINER_NAME}" > /dev/null 2>&1
+		echo "MSSQL test container removed."
+	else
+		echo "No MSSQL test container found."
+	fi
+}
+
+status_mssql() {
+	if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "MSSQL test container is running."
+		docker ps --filter "name=${CONTAINER_NAME}" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+	elif docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "MSSQL test container exists but is stopped."
+	else
+		echo "MSSQL test container is not running."
+	fi
+}
+
+case "${1}" in
+	start)
+		start_mssql
+		;;
+	stop)
+		stop_mssql
+		;;
+	status)
+		status_mssql
+		;;
+	*)
+		echo "Usage: $0 {start|stop|status}"
+		exit 1
+		;;
+esac

package/scripts/mysql-test-db.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# MySQL Test Database Management Script
+#
+# Usage:
+#   ./scripts/mysql-test-db.sh start   - Start MySQL container and wait for readiness
+#   ./scripts/mysql-test-db.sh stop    - Stop and remove the container
+#   ./scripts/mysql-test-db.sh status  - Check if the container is running
+#
+# The container settings match the test configuration in
+# test/Meadow-Provider-MySQL_tests.js:
+#   Host: localhost, Port: 3306, User: root
+#   Password: 123456789, Database: bookstore
+
+CONTAINER_NAME="meadow-mysql-test"
+MYSQL_ROOT_PASSWORD="123456789"
+MYSQL_DATABASE="bookstore"
+MYSQL_PORT="3306"
+MYSQL_IMAGE="mysql:8.0"
+
+start_mysql() {
+	# Check if container already exists
+	if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+			echo "MySQL test container is already running."
+			return 0
+		else
+			echo "Removing stopped container..."
+			docker rm "${CONTAINER_NAME}" > /dev/null 2>&1
+		fi
+	fi
+
+	echo "Starting MySQL test container..."
+	docker run -d \
+		--name "${CONTAINER_NAME}" \
+		-e MYSQL_ROOT_PASSWORD="${MYSQL_ROOT_PASSWORD}" \
+		-e MYSQL_DATABASE="${MYSQL_DATABASE}" \
+		-p "${MYSQL_PORT}:3306" \
+		"${MYSQL_IMAGE}" \
+		--default-authentication-plugin=mysql_native_password \
+		--character-set-server=utf8mb4 \
+		--collation-server=utf8mb4_unicode_ci
+
+	if [ $? -ne 0 ]; then
+		echo "ERROR: Failed to start MySQL container."
+		exit 1
+	fi
+
+	echo "Waiting for MySQL to be ready..."
+	RETRIES=30
+	until docker exec "${CONTAINER_NAME}" mysqladmin ping -h localhost -u root -p"${MYSQL_ROOT_PASSWORD}" --silent 2>/dev/null; do
+		RETRIES=$((RETRIES - 1))
+		if [ $RETRIES -le 0 ]; then
+			echo "ERROR: MySQL failed to become ready in time."
+			docker logs "${CONTAINER_NAME}" 2>&1 | tail -20
+			exit 1
+		fi
+		echo "  ...waiting (${RETRIES} retries left)"
+		sleep 2
+	done
+
+	echo ""
+	echo "MySQL test database is ready!"
+	echo "  Container: ${CONTAINER_NAME}"
+	echo "  Host:      localhost:${MYSQL_PORT}"
+	echo "  User:      root"
+	echo "  Password:  ${MYSQL_ROOT_PASSWORD}"
+	echo "  Database:  ${MYSQL_DATABASE}"
+	echo ""
+	echo "Run tests with: npm test"
+}
+
+stop_mysql() {
+	if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "Stopping and removing MySQL test container..."
+		docker stop "${CONTAINER_NAME}" > /dev/null 2>&1
+		docker rm "${CONTAINER_NAME}" > /dev/null 2>&1
+		echo "MySQL test container removed."
+	else
+		echo "No MySQL test container found."
+	fi
+}
+
+status_mysql() {
+	if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "MySQL test container is running."
+		docker ps --filter "name=${CONTAINER_NAME}" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+	elif docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "MySQL test container exists but is stopped."
+	else
+		echo "MySQL test container is not running."
+	fi
+}
+
+case "${1}" in
+	start)
+		start_mysql
+		;;
+	stop)
+		stop_mysql
+		;;
+	status)
+		status_mysql
+		;;
+	*)
+		echo "Usage: $0 {start|stop|status}"
+		exit 1
+		;;
+esac

package/source/Meadow.js

@@ -136,6 +136,7 @@ var Meadow = function()
 			'MeadowEndpoints': require(`./providers/Meadow-Provider-MeadowEndpoints.js`),
 			'MySQL': require(`./providers/Meadow-Provider-MySQL.js`),
 			'MSSQL': require(`./providers/Meadow-Provider-MSSQL.js`),
+			'SQLite': require(`./providers/Meadow-Provider-SQLite.js`),
 			'None': require(`./providers/Meadow-Provider-None.js`),
 		});
 		var setProvider = function(pProviderName)