meadow 2.0.42 → 2.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meadow",
-  "version": "2.0.42",
+  "version": "2.0.43",
   "description": "A data access library.",
   "main": "source/Meadow.js",
   "scripts": {
@@ -28,6 +28,11 @@
     "docker-postgresql-status": "./scripts/postgresql-test-db.sh status",
     "test-postgresql": "./scripts/postgresql-test-db.sh start && npx quack test -g Meadow-Provider-PostgreSQL",
     "test-postgresql-all": "./scripts/postgresql-test-db.sh start && npx mocha -u tdd --exit -R spec",
+    "docker-oracle-start": "./scripts/oracle-test-db.sh start",
+    "docker-oracle-stop": "./scripts/oracle-test-db.sh stop",
+    "docker-oracle-status": "./scripts/oracle-test-db.sh status",
+    "test-oracle": "./scripts/oracle-test-db.sh start && npx quack test -g Meadow-Provider-Oracle",
+    "test-oracle-all": "./scripts/oracle-test-db.sh start && npx mocha -u tdd --exit -R spec",
     "docker-mongodb-start": "./scripts/mongodb-test-db.sh start",
     "docker-mongodb-stop": "./scripts/mongodb-test-db.sh stop",
     "docker-mongodb-status": "./scripts/mongodb-test-db.sh status",
@@ -43,7 +48,7 @@
     "test-alasql": "npx quack test -g Meadow-Provider-ALASQL",
     "test-sqlite-browser": "npx quack test -g Meadow-Provider-SQLiteBrowser",
     "test-sqlite-browser-headless": "npx mocha -u tdd --exit --timeout 60000 test/Meadow-Provider-SQLiteBrowser-Headless_tests.js",
-    "test-all-providers": "./scripts/mysql-test-db.sh start && ./scripts/mssql-test-db.sh start && ./scripts/postgresql-test-db.sh start && ./scripts/mongodb-test-db.sh start && ./scripts/solr-test-db.sh start && ./scripts/dgraph-test-db.sh start && npx mocha -u tdd --exit -R spec",
+    "test-all-providers": "./scripts/mysql-test-db.sh start && ./scripts/mssql-test-db.sh start && ./scripts/postgresql-test-db.sh start && ./scripts/oracle-test-db.sh start && ./scripts/mongodb-test-db.sh start && ./scripts/solr-test-db.sh start && ./scripts/dgraph-test-db.sh start && npx mocha -u tdd --exit -R spec",
     "docker-cleanup": "./scripts/meadow-test-cleanup.sh",
     "test-cleanup": "./scripts/meadow-test-cleanup.sh"
   },
@@ -88,13 +93,15 @@
     "meadow-connection-mongodb": "^1.0.3",
     "meadow-connection-mssql": "^1.0.23",
     "meadow-connection-mysql": "^1.0.19",
-    "meadow-connection-postgresql": "^1.0.6",
+    "meadow-connection-oracle": "^1.0.2",
+    "meadow-connection-postgresql": "^1.0.7",
     "meadow-connection-rocksdb": "^1.0.0",
     "meadow-connection-solr": "^1.0.3",
     "meadow-connection-sqlite": "^1.0.20",
     "meadow-connection-sqlite-browser": "^1.0.2",
     "mongodb": "^6.12.0",
     "mysql2": "^3.18.2",
+    "oracledb": "^6.10.0",
     "pict-docuserve": "^1.4.12",
     "puppeteer": "^24.38.0",
     "quackage": "^1.3.0",
@@ -102,7 +109,7 @@
   },
   "dependencies": {
     "async": "3.2.6",
-    "foxhound": "^2.0.28",
+    "foxhound": "^2.0.29",
     "is-my-json-valid": "2.20.6",
     "simple-get": "^4.0.1"
   }

package/scripts/bookstore-seed.js

@@ -496,6 +496,138 @@ function emitMSSQL()
 	return tmpOut.join('\n');
 }
 
+// ---------------------------------------------------------------------------
+// Oracle emitter. Oracle has no CREATE TABLE IF NOT EXISTS; the docker script
+// runs this seed once against a fresh container, so plain CREATE TABLE is fine.
+// Output is sqlplus-friendly: SET DEFINE OFF stops the '&' in "Angels & Demons"
+// from being read as a substitution variable, and WHENEVER SQLERROR EXIT
+// FAILURE makes a bad statement fail the piped load. Identity columns + the
+// 23ai multi-row VALUES clause keep it close to the other dialects.
+// ---------------------------------------------------------------------------
+function emitOracle()
+{
+	const tmpOut = [];
+	tmpOut.push('-- Bookstore Schema and Seed Data for Meadow Oracle Tests');
+	tmpOut.push('-- Generated by scripts/bookstore-seed.js (GUIDs minted via fable-uuid)');
+	tmpOut.push('SET DEFINE OFF');
+	tmpOut.push('WHENEVER SQLERROR EXIT FAILURE');
+	tmpOut.push('');
+	tmpOut.push('CREATE TABLE Book');
+	tmpOut.push('    (');
+	tmpOut.push('        IDBook NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,');
+	tmpOut.push('        GUIDBook VARCHAR2(36) DEFAULT \'00000000-0000-0000-0000-000000000000\' NOT NULL,');
+	tmpOut.push('        CreateDate TIMESTAMP,');
+	tmpOut.push('        CreatingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        UpdateDate TIMESTAMP,');
+	tmpOut.push('        UpdatingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        Deleted NUMBER(1) DEFAULT 0 NOT NULL,');
+	tmpOut.push('        DeleteDate TIMESTAMP,');
+	tmpOut.push('        DeletingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        Title VARCHAR2(200) DEFAULT \' \' NOT NULL,');
+	tmpOut.push('        Type VARCHAR2(32) DEFAULT \' \' NOT NULL,');
+	tmpOut.push('        Genre VARCHAR2(128) DEFAULT \' \' NOT NULL,');
+	tmpOut.push('        ISBN VARCHAR2(64) DEFAULT \' \' NOT NULL,');
+	tmpOut.push('        Language VARCHAR2(12) DEFAULT \' \' NOT NULL,');
+	tmpOut.push('        ImageURL VARCHAR2(254) DEFAULT \' \' NOT NULL,');
+	tmpOut.push('        PublicationYear NUMBER DEFAULT 0 NOT NULL');
+	tmpOut.push('    );');
+	tmpOut.push('');
+	tmpOut.push('CREATE TABLE BookAuthorJoin');
+	tmpOut.push('    (');
+	tmpOut.push('        IDBookAuthorJoin NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,');
+	tmpOut.push('        GUIDBookAuthorJoin VARCHAR2(36) DEFAULT \'00000000-0000-0000-0000-000000000000\' NOT NULL,');
+	tmpOut.push('        IDBook NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        IDAuthor NUMBER DEFAULT 0 NOT NULL');
+	tmpOut.push('    );');
+	tmpOut.push('');
+	tmpOut.push('CREATE TABLE Author');
+	tmpOut.push('    (');
+	tmpOut.push('        IDAuthor NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,');
+	tmpOut.push('        GUIDAuthor VARCHAR2(36) DEFAULT \'00000000-0000-0000-0000-000000000000\' NOT NULL,');
+	tmpOut.push('        CreateDate TIMESTAMP,');
+	tmpOut.push('        CreatingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        UpdateDate TIMESTAMP,');
+	tmpOut.push('        UpdatingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        Deleted NUMBER(1) DEFAULT 0 NOT NULL,');
+	tmpOut.push('        DeleteDate TIMESTAMP,');
+	tmpOut.push('        DeletingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        Name VARCHAR2(200) DEFAULT \' \' NOT NULL');
+	tmpOut.push('    );');
+	tmpOut.push('');
+	tmpOut.push('CREATE TABLE BookPrice');
+	tmpOut.push('    (');
+	tmpOut.push('        IDBookPrice NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,');
+	tmpOut.push('        GUIDBookPrice VARCHAR2(36) DEFAULT \'00000000-0000-0000-0000-000000000000\' NOT NULL,');
+	tmpOut.push('        CreateDate TIMESTAMP,');
+	tmpOut.push('        CreatingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        UpdateDate TIMESTAMP,');
+	tmpOut.push('        UpdatingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        Deleted NUMBER(1) DEFAULT 0 NOT NULL,');
+	tmpOut.push('        DeleteDate TIMESTAMP,');
+	tmpOut.push('        DeletingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        Price NUMBER(8,2),');
+	tmpOut.push('        StartDate TIMESTAMP,');
+	tmpOut.push('        EndDate TIMESTAMP,');
+	tmpOut.push('        Discountable NUMBER(1) DEFAULT 0 NOT NULL,');
+	tmpOut.push('        CouponCode VARCHAR2(16) DEFAULT \' \' NOT NULL,');
+	tmpOut.push('        IDBook NUMBER DEFAULT 0 NOT NULL');
+	tmpOut.push('    );');
+	tmpOut.push('');
+	tmpOut.push('CREATE TABLE Review');
+	tmpOut.push('    (');
+	tmpOut.push('        IDReviews NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,');
+	tmpOut.push('        GUIDReviews VARCHAR2(36) DEFAULT \'00000000-0000-0000-0000-000000000000\' NOT NULL,');
+	tmpOut.push('        CreateDate TIMESTAMP,');
+	tmpOut.push('        CreatingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        UpdateDate TIMESTAMP,');
+	tmpOut.push('        UpdatingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        Deleted NUMBER(1) DEFAULT 0 NOT NULL,');
+	tmpOut.push('        DeleteDate TIMESTAMP,');
+	tmpOut.push('        DeletingIDUser NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        Text CLOB,');
+	tmpOut.push('        Rating NUMBER DEFAULT 0 NOT NULL,');
+	tmpOut.push('        IDBook NUMBER DEFAULT 0 NOT NULL');
+	tmpOut.push('    );');
+	tmpOut.push('');
+	tmpOut.push('-- Seed Data: First 20 books from books.csv');
+	tmpOut.push('-- Inserted in CSV order so IDBook matches CSV row number');
+	tmpOut.push('');
+	tmpOut.push('INSERT INTO Book (GUIDBook, Title, Type, Genre, ISBN, Language, ImageURL, PublicationYear, CreateDate, CreatingIDUser, UpdateDate, UpdatingIDUser) VALUES');
+	const tmpBookRows = BOOKS.map((pBook) =>
+	{
+		return '    (' + [
+			sqlQuote(tmpUUID.getUUID()),
+			sqlQuote(pBook.Title),
+			sqlQuote(pBook.Type),
+			sqlQuote(pBook.Genre),
+			sqlQuote(pBook.ISBN),
+			sqlQuote(pBook.Language),
+			sqlQuote(pBook.ImageURL),
+			pBook.PublicationYear,
+			'SYS_EXTRACT_UTC(SYSTIMESTAMP)', '99999', 'SYS_EXTRACT_UTC(SYSTIMESTAMP)', '99999'
+		].join(', ') + ')';
+	});
+	tmpOut.push(tmpBookRows.join(',\n') + ';');
+	tmpOut.push('');
+	tmpOut.push('-- Seed Data: Authors for the first 20 books');
+	tmpOut.push('');
+	tmpOut.push('INSERT INTO Author (GUIDAuthor, Name, CreateDate, CreatingIDUser, UpdateDate, UpdatingIDUser) VALUES');
+	const tmpAuthorRows = AUTHORS.map((pName) =>
+	{
+		return '    (' + [
+			sqlQuote(tmpUUID.getUUID()),
+			sqlQuote(pName),
+			'SYS_EXTRACT_UTC(SYSTIMESTAMP)', '99999', 'SYS_EXTRACT_UTC(SYSTIMESTAMP)', '99999'
+		].join(', ') + ')';
+	});
+	tmpOut.push(tmpAuthorRows.join(',\n') + ';');
+	tmpOut.push('');
+	tmpOut.push('COMMIT;');
+	tmpOut.push('EXIT');
+	tmpOut.push('');
+	return tmpOut.join('\n');
+}
+
 // ---------------------------------------------------------------------------
 // CLI
 // ---------------------------------------------------------------------------
@@ -532,7 +664,10 @@ switch (tmpDialect)
 	case 'mssql':
 		process.stdout.write(emitMSSQL());
 		break;
+	case 'oracle':
+		process.stdout.write(emitOracle());
+		break;
 	default:
-		process.stderr.write('Usage: bookstore-seed.js --dialect <mysql|postgresql|mssql>\n');
+		process.stderr.write('Usage: bookstore-seed.js --dialect <mysql|postgresql|mssql|oracle>\n');
 		process.exit(1);
 }

package/scripts/meadow-test-cleanup.sh

@@ -14,6 +14,7 @@ echo ""
 "${SCRIPT_DIR}/mysql-test-db.sh" stop
 "${SCRIPT_DIR}/mssql-test-db.sh" stop
 "${SCRIPT_DIR}/postgresql-test-db.sh" stop
+"${SCRIPT_DIR}/oracle-test-db.sh" stop
 "${SCRIPT_DIR}/mongodb-test-db.sh" stop
 "${SCRIPT_DIR}/solr-test-db.sh" stop
 "${SCRIPT_DIR}/dgraph-test-db.sh" stop

package/scripts/oracle-test-db.sh

@@ -0,0 +1,128 @@
+#!/bin/bash
+# Oracle Test Database Management Script
+#
+# Usage:
+#   ./scripts/oracle-test-db.sh start   - Start Oracle container, load schema and seed data
+#   ./scripts/oracle-test-db.sh stop    - Stop and remove the container
+#   ./scripts/oracle-test-db.sh status  - Check if the container is running
+#
+# Uses gvenzl/oracle-free (Oracle Database 23ai Free — no license required,
+# multi-arch so it runs natively on Apple Silicon).  gvenzl auto-creates the
+# APP_USER in its own schema inside the FREEPDB1 pluggable database.
+#
+# The container settings match the test configuration in
+# test/Meadow-Provider-Oracle_tests.js and meadow-connection-oracle:
+#   Host: 127.0.0.1, Port: 21521, Service: FREEPDB1
+#   User: bookstore, Password: Retold1234567890!
+
+CONTAINER_NAME="meadow-oracle-test"
+ORACLE_USER="bookstore"
+ORACLE_PASSWORD="Retold1234567890!"
+ORACLE_SERVICE="FREEPDB1"
+ORACLE_PORT="21521"
+ORACLE_IMAGE="gvenzl/oracle-free:23-slim"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SEED_GENERATOR="${SCRIPT_DIR}/bookstore-seed.js"
+
+start_oracle() {
+	# 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 "Oracle test container is already running."
+			return 0
+		else
+			echo "Removing stopped container..."
+			docker rm "${CONTAINER_NAME}" > /dev/null 2>&1
+		fi
+	fi
+
+	echo "Starting Oracle test container (first boot pulls the image and initializes the DB; this can take several minutes)..."
+	docker run -d \
+		--name "${CONTAINER_NAME}" \
+		-e ORACLE_PASSWORD="${ORACLE_PASSWORD}" \
+		-e APP_USER="${ORACLE_USER}" \
+		-e APP_USER_PASSWORD="${ORACLE_PASSWORD}" \
+		-p "${ORACLE_PORT}:1521" \
+		"${ORACLE_IMAGE}"
+
+	if [ $? -ne 0 ]; then
+		echo "ERROR: Failed to start Oracle container."
+		exit 1
+	fi
+
+	echo "Waiting for Oracle to accept connections (gvenzl healthcheck)..."
+	RETRIES=120
+	until docker exec "${CONTAINER_NAME}" healthcheck.sh > /dev/null 2>&1; do
+		RETRIES=$((RETRIES - 1))
+		if [ $RETRIES -le 0 ]; then
+			echo "ERROR: Oracle failed to become ready in time."
+			docker logs "${CONTAINER_NAME}" 2>&1 | tail -20
+			exit 1
+		fi
+		echo "  ...waiting (${RETRIES} retries left)"
+		sleep 5
+	done
+
+	# Load bookstore schema and seed data (GUIDs minted at generation time via fable-uuid)
+	if [ -f "${SEED_GENERATOR}" ]; then
+		echo "Loading bookstore schema and seed data..."
+		node "${SEED_GENERATOR}" --dialect oracle | \
+			docker exec -i "${CONTAINER_NAME}" sqlplus -S "${ORACLE_USER}/${ORACLE_PASSWORD}@//localhost:1521/${ORACLE_SERVICE}"
+		if [ $? -ne 0 ]; then
+			echo "WARNING: Failed to load seed data. Tests requiring pre-populated data may fail."
+		else
+			echo "Bookstore schema and seed data loaded successfully."
+		fi
+	else
+		echo "WARNING: Seed generator not found at ${SEED_GENERATOR}. Skipping schema/data loading."
+	fi
+
+	echo ""
+	echo "Oracle test database is ready!"
+	echo "  Container: ${CONTAINER_NAME}"
+	echo "  Host:      127.0.0.1:${ORACLE_PORT}"
+	echo "  Service:   ${ORACLE_SERVICE}"
+	echo "  User:      ${ORACLE_USER}"
+	echo "  Password:  ${ORACLE_PASSWORD}"
+	echo ""
+	echo "Run tests with: npm test"
+}
+
+stop_oracle() {
+	if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "Stopping and removing Oracle test container..."
+		docker stop "${CONTAINER_NAME}" > /dev/null 2>&1
+		docker rm "${CONTAINER_NAME}" > /dev/null 2>&1
+		echo "Oracle test container removed."
+	else
+		echo "No Oracle test container found."
+	fi
+}
+
+status_oracle() {
+	if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+		echo "Oracle 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 "Oracle test container exists but is stopped."
+	else
+		echo "Oracle test container is not running."
+	fi
+}
+
+case "${1}" in
+	start)
+		start_oracle
+		;;
+	stop)
+		stop_oracle
+		;;
+	status)
+		status_oracle
+		;;
+	*)
+		echo "Usage: $0 {start|stop|status}"
+		exit 1
+		;;
+esac

package/source/providers/Meadow-Provider-Oracle.js

@@ -305,7 +305,11 @@ var MeadowProvider = function ()
 			executeStatement(pQuery.query.body, tmpBinds, function (pError, pDBResult)
 			{
 				tmpResult.error = pError;
-				tmpResult.value = pDBResult ? pDBResult.rowsAffected : 0;
+				// The Meadow Update behavior requires result.value to be an
+				// object; oracledb's UPDATE result has no rows array (no
+				// RETURNING), so mirror the PostgreSQL provider and expose an
+				// (empty) array. The post-update Read supplies the record.
+				tmpResult.value = (pDBResult && pDBResult.rows) ? pDBResult.rows : [];
 				tmpResult.executed = true;
 				return fCallback();
 			});

package/test/Meadow-Provider-Oracle_tests.js

@@ -0,0 +1,877 @@
+/**
+* Unit tests for the Meadow "Oracle" Provider
+*
+* These tests expect an Oracle database (see scripts/oracle-test-db.sh —
+* gvenzl/oracle-free on port 21521).  If meadow-connection-oracle is not
+* installed, or no Oracle is reachable, the whole suite self-skips so a bare
+* `npm test` (or test-all-providers without Oracle) doesn't hard-fail.
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var Chai = require("chai");
+var Expect = Chai.expect;
+
+// Tolerate the connection module (and its oracledb dependency) being absent —
+// the suite self-skips in that case rather than breaking the whole test run.
+var libMeadowConnectionOracle = null;
+try
+{
+	libMeadowConnectionOracle = require('meadow-connection-oracle');
+}
+catch (pRequireError)
+{
+	libMeadowConnectionOracle = null;
+}
+
+var tmpFableSettings = (
+	{
+		"Product": "MeadowOracleTestBookstore",
+		"ProductVersion": "1.0.0",
+
+		"UUID":
+		{
+			"DataCenter": 0,
+			"Worker": 0
+		},
+		"LogStreams":
+			[
+				{
+					"streamtype": "console"
+				}
+			],
+
+		"Oracle":
+		{
+			"Server": "127.0.0.1",
+			"Port": 21521,
+			"User": "bookstore",
+			"Password": "Retold1234567890!",
+			"connectionType": "ServiceName",
+			"serviceName": "FREEPDB1",
+			"ConnectionPoolLimit": 5,
+			// Fail fast into a self-skip when no Oracle is reachable.
+			"ConnectRetryOptions": { "MaxAttempts": 1 },
+			"ConnectionTimeoutMs": 8000
+		}
+	});
+
+var libFable = new (require('fable'))(tmpFableSettings);
+
+if (libMeadowConnectionOracle)
+{
+	libFable.serviceManager.addServiceType('MeadowOracleProvider', libMeadowConnectionOracle);
+	libFable.serviceManager.instantiateServiceProvider('MeadowOracleProvider');
+}
+
+var _AnimalJsonSchema = (
+	{
+		title: "Animal",
+		description: "A creature that lives in a meadow.",
+		type: "object",
+		properties: {
+			IDAnimal: {
+				description: "The unique identifier for an animal",
+				type: "integer"
+			},
+			Name: {
+				description: "The animal's name",
+				type: "string"
+			},
+			Type: {
+				description: "The type of the animal",
+				type: "string"
+			}
+		},
+		required: ["IDAnimal", "Name", "CreatingIDUser"]
+	});
+var _AnimalSchema = (
+	[
+		{ Column: "IDAnimal", Type: "AutoIdentity" },
+		{ Column: "GUIDAnimal", Type: "AutoGUID" },
+		{ Column: "CreateDate", Type: "CreateDate" },
+		{ Column: "CreatingIDUser", Type: "CreateIDUser" },
+		{ Column: "UpdateDate", Type: "UpdateDate" },
+		{ Column: "UpdatingIDUser", Type: "UpdateIDUser" },
+		{ Column: "Deleted", Type: "Deleted" },
+		{ Column: "DeletingIDUser", Type: "DeleteIDUser" },
+		{ Column: "DeleteDate", Type: "DeleteDate" },
+		{ Column: "Name", Type: "String" },
+		{ Column: "Type", Type: "String" },
+		{ Column: "Metadata",  Type:"JSON" },
+		{ Column: "ExtraData", Type:"JSONProxy", StorageColumn:"ExtraDataJSON" }
+	]);
+var _AnimalDefault = (
+	{
+		IDAnimal: null,
+		GUIDAnimal: '',
+
+		CreateDate: false,
+		CreatingIDUser: 0,
+		UpdateDate: false,
+		UpdatingIDUser: 0,
+		Deleted: 0,
+		DeleteDate: false,
+		DeletingIDUser: 0,
+
+		Name: 'Unknown',
+		Type: 'Unclassified',
+
+		Metadata: {},
+		ExtraData: {}
+	});
+
+suite
+	(
+		'Meadow-Provider-Oracle',
+		function ()
+		{
+			var _SpooledUp = false;
+
+			// Oracle has no DROP TABLE IF EXISTS — swallow ORA-00942.
+			var _DropTableStatement = "BEGIN EXECUTE IMMEDIATE 'DROP TABLE FableTest CASCADE CONSTRAINTS'; EXCEPTION WHEN OTHERS THEN IF SQLCODE != -942 THEN RAISE; END IF; END;";
+
+			var _CreateTableStatement = 'CREATE TABLE FableTest ('
+				+ ' IDAnimal NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,'
+				+ " GUIDAnimal VARCHAR2(36) DEFAULT '00000000-0000-0000-0000-000000000000' NOT NULL,"
+				+ ' CreateDate TIMESTAMP,'
+				+ ' CreatingIDUser NUMBER DEFAULT 0 NOT NULL,'
+				+ ' UpdateDate TIMESTAMP,'
+				+ ' UpdatingIDUser NUMBER DEFAULT 0 NOT NULL,'
+				+ ' Deleted NUMBER(1) DEFAULT 0 NOT NULL,'
+				+ ' DeleteDate TIMESTAMP,'
+				+ ' DeletingIDUser NUMBER DEFAULT 0 NOT NULL,'
+				+ " Name VARCHAR2(128) DEFAULT ' ' NOT NULL,"
+				+ " Type VARCHAR2(128) DEFAULT ' ' NOT NULL,"
+				+ ' Metadata CLOB,'
+				+ ' ExtraDataJSON CLOB'
+				+ ' )';
+
+			var getAnimalInsert = function (pName, pType)
+			{
+				return "INSERT INTO FableTest (GUIDAnimal, CreateDate, CreatingIDUser, UpdateDate, UpdatingIDUser, Deleted, DeleteDate, DeletingIDUser, Name, Type, Metadata, ExtraDataJSON)"
+					+ " VALUES ('00000000-0000-0000-0000-000000000000', SYS_EXTRACT_UTC(SYSTIMESTAMP), 1, SYS_EXTRACT_UTC(SYSTIMESTAMP), 1, 0, NULL, 0, '"
+					+ pName + "', '" + pType + "', '{}', '{}')";
+			};
+
+			// Acquire a pooled connection, run a statement with autoCommit, and
+			// always release the connection (oracledb has no pool.query()).
+			var execOnPool = function (pSQL, fCallback)
+			{
+				var tmpProvider = libFable.MeadowOracleProvider;
+				tmpProvider.getConnection(function (pConnectionError, pConnection)
+				{
+					if (pConnectionError) { return fCallback(pConnectionError); }
+					pConnection.execute(pSQL, [], { autoCommit: true })
+						.then(function () { pConnection.close().then(() => fCallback()).catch(() => fCallback()); })
+						.catch(function (pError) { pConnection.close().then(() => fCallback(pError)).catch(() => fCallback(pError)); });
+				});
+			};
+
+			var newMeadow = function ()
+			{
+				return require('../source/Meadow.js')
+					.new(libFable, 'FableTest')
+					.setProvider('Oracle')
+					.setSchema(_AnimalSchema)
+					.setJsonSchema(_AnimalJsonSchema)
+					.setDefaultIdentifier('IDAnimal')
+					.setDefault(_AnimalDefault)
+			};
+
+			suiteSetup
+				(
+					function (fDone)
+					{
+						var tmpSelf = this;
+
+						// No connection module installed → skip the whole suite.
+						if (!libMeadowConnectionOracle)
+						{
+							return tmpSelf.skip();
+						}
+
+						if (_SpooledUp)
+						{
+							return fDone();
+						}
+
+						libFable.MeadowOracleProvider.connectAsync(
+							(pConnectError) =>
+							{
+								if (pConnectError)
+								{
+									// No reachable Oracle → skip the whole suite.
+									libFable.log.warn(`Oracle not reachable, skipping Meadow-Provider-Oracle suite: ${pConnectError}`);
+									return tmpSelf.skip();
+								}
+
+								libFable.log.info('Connection opened!');
+								libFable.Utility.waterfall(
+									[
+										function (fStageComplete)
+										{
+											execOnPool(_DropTableStatement, () => fStageComplete());
+										},
+										function (fStageComplete)
+										{
+											execOnPool(_CreateTableStatement, fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Foo Foo', 'Bunny'), fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Red Riding Hood', 'Girl'), fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Red', 'Dog'), fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Spot', 'Dog'), fStageComplete);
+										},
+										function (fStageComplete)
+										{
+											execOnPool(getAnimalInsert('Gertrude', 'Frog'), fStageComplete);
+										}
+									],
+									function (pError)
+									{
+										if (pError)
+										{
+											libFable.log.error(`Error preparing Oracle test data: ${pError}`);
+											return fDone(pError);
+										}
+										_SpooledUp = true;
+										fDone();
+									}
+								);
+							}
+						);
+					}
+				);
+
+			suiteTeardown((fDone) =>
+			{
+				if (libFable.MeadowOracleProvider && libFable.MeadowOracleProvider.pool)
+				{
+					try
+					{
+						libFable.MeadowOracleProvider.pool.close(0).then(() => fDone()).catch(() => fDone());
+					}
+					catch (pError)
+					{
+						return fDone();
+					}
+				}
+				else
+				{
+					fDone();
+				}
+			});
+
+			suite
+				(
+					'Object Sanity',
+					function ()
+					{
+						test
+							(
+								'The Oracle class should initialize itself into a happy little object.',
+								function ()
+								{
+									var testMeadow = require('../source/Meadow.js').new(libFable).setProvider('Oracle');
+									Expect(testMeadow).to.be.an('object', 'Meadow should initialize as an object directly from the require statement.');
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Query Processing',
+					function ()
+					{
+						test
+							(
+								'Create a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow().setIDUser(90210);
+
+									var tmpQuery = testMeadow.query.clone().setLogLevel(5)
+										.addRecord({ Name: 'Blastoise', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('Blastoise');
+											Expect(pRecord.CreatingIDUser)
+												.to.equal(90210);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Create a record with JSON data',
+								function (fDone)
+								{
+									var testMeadow = newMeadow().setIDUser(90210);
+
+									var tmpQuery = testMeadow.query.clone().setLogLevel(5)
+										.addRecord({ Name: 'Moose', Type: 'Mammal', Metadata: { habitat: 'forest', weight: 500 }, ExtraData: { endangered: false, population: 'stable' } });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('Moose');
+											Expect(pRecord.Metadata)
+												.to.be.an('object');
+											Expect(pRecord.Metadata.habitat)
+												.to.equal('forest');
+											Expect(pRecord.ExtraData)
+												.to.be.an('object');
+											Expect(pRecord.ExtraData.endangered)
+												.to.equal(false);
+											// The storage column should not be exposed on the marshaled record
+											Expect(pRecord).to.not.have.property('ExtraDataJSON');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read a record from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addFilter('IDAnimal', 1);
+
+									testMeadow.doRead(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord.IDAnimal)
+												.to.equal(1);
+											Expect(pRecord.Name)
+												.to.equal('Foo Foo');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read all records from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									testMeadow.doReads(testMeadow.query.addSort({Column: 'IDAnimal'}),
+										function (pError, pQuery, pRecords)
+										{
+											Expect(pRecords[0].IDAnimal)
+												.to.equal(1);
+											Expect(pRecords[0].Name)
+												.to.equal('Foo Foo');
+											Expect(pRecords[1].IDAnimal)
+												.to.equal(2);
+											Expect(pRecords[1].Name)
+												.to.equal('Red Riding Hood');
+											Expect(pRecords[1].Type)
+												.to.equal('Girl');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addRecord({ IDAnimal: 2, Type: 'Human' });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Type)
+												.to.equal('Human');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Delete a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query.addFilter('IDAnimal', 3);
+
+									testMeadow.doDelete(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											// It returns the number of rows deleted
+											Expect(pRecord)
+												.to.equal(1);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Undelete a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpDeleteQuery = testMeadow.query.addFilter('IDAnimal', 5);
+
+									// Make sure the record is deleted!
+									testMeadow.doDelete(tmpDeleteQuery,
+										function (pDeleteError, pDeleteQuery, pDeleteRecord)
+										{
+											var tmpQuery = testMeadow.query.addFilter('IDAnimal', 5);
+											testMeadow.doUndelete(tmpQuery,
+												function (pError, pQuery, pRecord)
+												{
+													// It returns the number of rows undeleted
+													Expect(pRecord)
+														.to.equal(1);
+													fDone();
+												});
+										});
+								}
+							);
+						test
+							(
+								'Count all records from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									Expect(testMeadow.query.parameters.result.executed)
+										.to.equal(false);
+									testMeadow.doCount(testMeadow.query,
+										function (pError, pQuery, pRecord)
+										{
+											// There should be 6 records
+											Expect(pRecord)
+												.to.equal(6);
+											Expect(pQuery.parameters.result.executed)
+												.to.equal(true);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Perform operations with a schema-based instantiation',
+								function (fDone)
+								{
+									var testMeadow = require('../source/Meadow.js').new(libFable)
+										.loadFromPackage(__dirname + '/Animal.json').setProvider('Oracle');
+
+									// Make sure the authentication stuff got loaded
+									Expect(testMeadow.schemaFull.authorizer.User)
+										.to.be.an('object');
+									Expect(testMeadow.schemaFull.authorizer.User.Create)
+										.to.equal('Allow');
+
+									var tmpQuery = testMeadow.query
+										.addRecord({ Name: 'Grommet', Type: 'Dog' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('Grommet');
+											fDone();
+										}
+									)
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Logged Query Processing',
+					function ()
+					{
+						test
+							(
+								'Create a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ Name: 'MewTwo', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('MewTwo');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Create a record in the database with a predefined GUID',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ Name: 'MewThree', GUIDAnimal: '0x12345', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('MewThree');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Create a record in the database with a previously predefined GUID -- expect failure',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ Name: 'MewThree', GUIDAnimal: '0x12345', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal("Record with GUID 0x12345 already exists!");
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read a record from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addFilter('IDAnimal', 1);
+
+									testMeadow.doRead(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord.IDAnimal)
+												.to.equal(1);
+											Expect(pRecord.Name)
+												.to.equal('Foo Foo');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read all records from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									testMeadow.doReads(testMeadow.query.setLogLevel(5).addSort({Column: 'IDAnimal'}),
+										function (pError, pQuery, pRecords)
+										{
+											Expect(pRecords[0].IDAnimal)
+												.to.equal(1);
+											Expect(pRecords[0].Name)
+												.to.equal('Foo Foo');
+											Expect(pRecords[1].IDAnimal)
+												.to.equal(2);
+											Expect(pRecords[1].Name)
+												.to.equal('Red Riding Hood');
+											Expect(pRecords[1].Type)
+												.to.equal('Human');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ IDAnimal: 2, Type: 'HumanGirl' });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Type)
+												.to.equal('HumanGirl');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Delete a record in the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addFilter('IDAnimal', 4);
+
+									testMeadow.doDelete(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											// It returns the number of rows deleted
+											Expect(pRecord)
+												.to.equal(1);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Count all records from the database',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									testMeadow.doCount(testMeadow.query.setLogLevel(5),
+										function (pError, pQuery, pRecord)
+										{
+											// There should be 8 records
+											Expect(pRecord)
+												.to.equal(8);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read a record from the database that had a defined GUID',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addFilter('GUIDAnimal', '0x12345');
+
+									testMeadow.doRead(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('MewThree');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Create a record in the database with a defined creating user',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+									var tmpQuery = testMeadow.query
+										.setIDUser(800)
+										.addRecord({ Name: 'MewSix', GUIDAnimal: '0x123456', Type: 'Pokemon' });
+
+									testMeadow.doCreate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pRecord.Name)
+												.to.equal('MewSix');
+											Expect(pRecord.CreatingIDUser)
+												.to.equal(800);
+											fDone();
+										}
+									)
+								}
+							);
+					}
+				);
+			suite
+				(
+					'The Bad Kind of Query Processing',
+					function ()
+					{
+						test
+							(
+								'Create a record in the database with no record',
+								function (fDone)
+								{
+									var testMeadow = newMeadow().setDefaultIdentifier('Type');
+
+									testMeadow.doCreate(testMeadow.query,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('No record submitted');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read a record from the database with no data returned',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addFilter('IDAnimal', 5000);
+									testMeadow.doRead(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord)
+												.to.equal(false);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Read records from the database with no data returned',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addFilter('IDAnimal', 5000);
+
+									testMeadow.doReads(tmpQuery,
+										function (pError, pQuery, pRecord)
+										{
+											Expect(pRecord.length)
+												.to.equal(0);
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database with a bad filter',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.setLogLevel(5)
+										.addRecord({ IDAnimal: undefined, Type: 'HumanGirl' });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('Automated update missing filters... aborting!');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database without passing a record in',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									testMeadow.doUpdate(testMeadow.query,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('No record submitted');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database with a bad record passed in (no default identifier)',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addRecord({ Name: 'Bill' });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('Automated update missing default identifier');
+											fDone();
+										}
+									)
+								}
+							);
+						test
+							(
+								'Update a record in the database that does not exist',
+								function (fDone)
+								{
+									var testMeadow = newMeadow();
+
+									var tmpQuery = testMeadow.query
+										.addRecord({ IDAnimal: 983924 });
+
+									testMeadow.doUpdate(tmpQuery,
+										function (pError, pQuery, pQueryRead, pRecord)
+										{
+											Expect(pError)
+												.to.equal('No record found to update!');
+											fDone();
+										}
+									)
+								}
+							);
+					}
+				);
+		}
+	);