meadow 2.0.27 → 2.0.29

package/.quackage.json

@@ -0,0 +1,9 @@
+{
+	"GulpExecutions": [
+	{
+		"Hash": "default",
+		"Name": "Default standard build.",
+		"BuildFileLabel": "",
+		"BrowsersListRC": "since 2022"
+	}]
+}

package/README.md

@@ -41,6 +41,7 @@ const meadow = libMeadow.new(libFable, 'Book')
 		{ Column: 'GUIDBook', Type: 'AutoGUID' },
 		{ Column: 'Title', Type: 'String', Size: '255' },
 		{ Column: 'Author', Type: 'String', Size: '128' },
+		{ Column: 'Metadata', Type: 'JSON' },
 		{ Column: 'CreateDate', Type: 'CreateDate' },
 		{ Column: 'CreatingIDUser', Type: 'CreateIDUser' },
 		{ Column: 'UpdateDate', Type: 'UpdateDate' },
@@ -92,6 +93,8 @@ meadow.doReads(meadow.query.setCap(25).setBegin(0),
 | `DeleteDate` | Auto-populated timestamp on delete |
 | `DeleteIDUser` | Auto-populated user ID on delete |
 | `Deleted` | Soft delete flag (enables logical deletion) |
+| `JSON` | Structured JSON data (stored as `TEXT`, marshaled to/from objects) |
+| `JSONProxy` | JSON stored in a different SQL column (uses `StorageColumn` for SQL, virtual name for objects) |
 
 ## CRUD Operations
 

package/docs/_sidebar.md

@@ -8,6 +8,7 @@
 - Core Concepts
 
   - [Schema](schema/README.md)
+  - [JSON Columns](schema/json-columns.md)
   - [Query DSL](query-dsl.md)
   - [Raw Queries](raw-queries.md)
   - [Audit Tracking](audit-tracking.md)

package/docs/schema/README.md

@@ -34,6 +34,8 @@ const tmpSchema =
 	{ Column: 'InPrint', Type: 'Boolean' },
 	{ Column: 'PublishDate', Type: 'DateTime' },
 	{ Column: 'Synopsis', Type: 'Text' },
+	{ Column: 'Metadata', Type: 'JSON' },
+	{ Column: 'Extras', Type: 'JSONProxy', StorageColumn: 'ExtrasJSON' },
 	{ Column: 'CreateDate', Type: 'CreateDate' },
 	{ Column: 'CreatingIDUser', Type: 'CreateIDUser' },
 	{ Column: 'UpdateDate', Type: 'UpdateDate' },
@@ -59,6 +61,40 @@ meadow.setSchema(tmpSchema);
 | `Decimal` | Decimal number | `DECIMAL(precision,scale)` | `0` |
 | `Boolean` | Boolean flag | `INT` / `BOOLEAN` | `0` |
 | `DateTime` | Date/time field | `DATETIME` | `null` |
+| `JSON` | Structured JSON data | `LONGTEXT` (MySQL) / `TEXT` (others) | `{}` |
+| `JSONProxy` | JSON with different SQL column name | `LONGTEXT` / `TEXT` (on `StorageColumn`) | `{}` |
+
+### JSON Column Types
+
+The `JSON` and `JSONProxy` types store structured data as serialized JSON text in SQL databases. Meadow handles serialization and deserialization automatically in the provider layer.
+
+**JSON** -- the SQL column and object property share the same name:
+
+```javascript
+{ Column: 'Metadata', Type: 'JSON' }
+```
+
+On create/update, the object value is `JSON.stringify`'d into the `Metadata` TEXT column. On read, the text is `JSON.parse`'d back into an object on `record.Metadata`.
+
+**JSONProxy** -- the SQL column name differs from the JavaScript property:
+
+```javascript
+{ Column: 'Preferences', Type: 'JSONProxy', StorageColumn: 'PreferencesJSON' }
+```
+
+On create/update, the value from `record.Preferences` is `JSON.stringify`'d and stored in the `PreferencesJSON` SQL column. On read, `PreferencesJSON` is parsed and mapped to `record.Preferences`. The storage column (`PreferencesJSON`) is never exposed on the marshaled record object.
+
+This separation is useful when you want a clean API surface (`record.Preferences`) while keeping a database naming convention that makes the storage format explicit (`PreferencesJSON`).
+
+For object-store providers (MongoDB, RocksDB), JSON values are stored and retrieved as native objects -- no serialization is needed.
+
+JSON columns support the standard `Column` and `Type` properties, plus:
+
+| Property | Required | Description |
+|----------|----------|-------------|
+| `StorageColumn` | JSONProxy only | The actual SQL column name for storage |
+
+See [JSON Columns](json-columns.md) for detailed examples and filtering.
 
 ### Audit Column Types
 

package/docs/schema/json-columns.md

@@ -0,0 +1,188 @@
+# JSON Columns
+
+> Store structured data as JSON in SQL databases with automatic serialization
+
+Meadow supports two column types for storing structured JSON data: `JSON` and `JSONProxy`. Both store data as `TEXT` in SQL databases and handle serialization/deserialization automatically. Object-store providers (MongoDB, RocksDB) store these values as native objects.
+
+## JSON Type
+
+The `JSON` type stores structured data in a column where the SQL name and JavaScript property name are identical.
+
+### Schema Definition
+
+```javascript
+{ Column: 'Metadata', Type: 'JSON' }
+```
+
+### MicroDDL Syntax
+
+```
+{Metadata
+```
+
+### Behavior
+
+| Operation | What Happens |
+|-----------|-------------|
+| **Create** | `record.Metadata` is `JSON.stringify`'d into the `Metadata` TEXT column |
+| **Read** | The `Metadata` TEXT column is `JSON.parse`'d into `record.Metadata` (an object) |
+| **Update** | Same as Create -- the value is serialized before writing |
+| **Default** | `{}` (empty object) |
+
+### Example
+
+```javascript
+// Schema
+const schema = [
+	{ Column: 'IDProduct', Type: 'AutoIdentity' },
+	{ Column: 'Name', Type: 'String', Size: '128' },
+	{ Column: 'Metadata', Type: 'JSON' },
+	// ... audit columns
+];
+
+// Create with JSON data
+meadow.doCreate(
+	meadow.query.addRecord({
+		Name: 'Widget',
+		Metadata: { color: 'blue', weight: 1.5, tags: ['sale', 'new'] }
+	}),
+	(pError, pCreateQuery, pReadQuery, pRecord) =>
+	{
+		console.log(pRecord.Metadata);
+		// => { color: 'blue', weight: 1.5, tags: ['sale', 'new'] }
+		console.log(typeof pRecord.Metadata);
+		// => 'object'
+	});
+```
+
+## JSONProxy Type
+
+The `JSONProxy` type stores JSON in a SQL column with a different name than the JavaScript property. This is useful when you want a clean API surface while keeping an explicit naming convention in the database.
+
+### Schema Definition
+
+```javascript
+{ Column: 'Preferences', Type: 'JSONProxy', StorageColumn: 'PreferencesJSON' }
+```
+
+| Property | Description |
+|----------|-------------|
+| `Column` | The JavaScript property name (virtual) -- what API consumers see |
+| `StorageColumn` | The actual SQL column name -- what the database stores |
+
+### MicroDDL Syntax
+
+```
+{Preferences PreferencesJSON
+```
+
+### Behavior
+
+| Operation | What Happens |
+|-----------|-------------|
+| **Create** | `record.Preferences` is `JSON.stringify`'d into the `PreferencesJSON` SQL column |
+| **Read** | The `PreferencesJSON` column is `JSON.parse`'d and mapped to `record.Preferences`; `PreferencesJSON` is **not** exposed on the result |
+| **Update** | Same as Create -- serialized to the storage column |
+| **Default** | `{}` (empty object) |
+
+### Example
+
+```javascript
+// Schema
+const schema = [
+	{ Column: 'IDUser', Type: 'AutoIdentity' },
+	{ Column: 'Name', Type: 'String', Size: '128' },
+	{ Column: 'Preferences', Type: 'JSONProxy', StorageColumn: 'PreferencesJSON' },
+	// ... audit columns
+];
+
+// Create
+meadow.doCreate(
+	meadow.query.addRecord({
+		Name: 'Alice',
+		Preferences: { theme: 'dark', language: 'en', notifications: true }
+	}),
+	(pError, pCreateQuery, pReadQuery, pRecord) =>
+	{
+		console.log(pRecord.Preferences);
+		// => { theme: 'dark', language: 'en', notifications: true }
+
+		console.log(pRecord.PreferencesJSON);
+		// => undefined (storage column is hidden)
+	});
+```
+
+## SQL Storage
+
+In SQL databases, both JSON types are stored as text columns. MySQL uses `LONGTEXT` (up to 4GB) to avoid the 64KB limit of `TEXT`. Other databases use `TEXT` (unlimited in PostgreSQL and SQLite) or `NVARCHAR(MAX)` (MSSQL).
+
+| Provider | JSON DDL | JSONProxy DDL |
+|----------|----------|---------------|
+| MySQL | `Metadata LONGTEXT` | `PreferencesJSON LONGTEXT` |
+| PostgreSQL | `"Metadata" TEXT` | `"PreferencesJSON" TEXT` |
+| SQLite | `Metadata TEXT` | `PreferencesJSON TEXT` |
+| MSSQL | `[Metadata] NVARCHAR(MAX)` | `[PreferencesJSON] NVARCHAR(MAX)` |
+
+## Filtering on JSON Properties
+
+FoxHound supports filtering on nested JSON properties using dot notation:
+
+```javascript
+// Filter by a JSON property
+meadow.doReads(
+	meadow.query.addFilter('Metadata.color', 'blue'),
+	(pError, pQuery, pRecords) =>
+	{
+		// Returns records where Metadata contains { color: 'blue' }
+	});
+
+// Comparison operators work too
+meadow.doReads(
+	meadow.query.addFilter('Metadata.weight', 2.0, '>='),
+	(pError, pQuery, pRecords) =>
+	{
+		// Returns records where Metadata.weight >= 2.0
+	});
+```
+
+The generated SQL uses dialect-specific JSON path functions:
+
+| Dialect | Generated SQL |
+|---------|---------------|
+| MySQL | `JSON_EXTRACT(Metadata, '$.color') = :Metadata_color_w0` |
+| PostgreSQL | `Metadata->>'color' = :Metadata_color_w0` |
+| SQLite | `json_extract(Metadata, '$.color') = :Metadata_color_w0` |
+| MSSQL | `JSON_VALUE(Metadata, '$.color') = :Metadata_color_w0` |
+
+Nested paths are supported (e.g., `Metadata.dimensions.width`).
+
+For `JSONProxy` columns, the storage column is used in the SQL expression automatically. Filtering on `Preferences.theme` produces `json_extract(PreferencesJSON, '$.theme')` in SQLite.
+
+## Package File Format
+
+When using a JSON package file to define your schema:
+
+```json
+{
+	"Scope": "Product",
+	"DefaultIdentifier": "IDProduct",
+	"Schema": [
+		{ "Column": "IDProduct", "Type": "AutoIdentity" },
+		{ "Column": "Name", "Type": "String", "Size": "128" },
+		{ "Column": "Metadata", "Type": "JSON" },
+		{ "Column": "Preferences", "Type": "JSONProxy", "StorageColumn": "PreferencesJSON" }
+	],
+	"DefaultObject": {
+		"IDProduct": null,
+		"Name": "",
+		"Metadata": {},
+		"Preferences": {}
+	}
+}
+```
+
+Note that `DefaultObject` uses the virtual property name (`Preferences`), not the storage column name.
+
+## Object Store Providers
+
+MongoDB and RocksDB store JSON values as native objects -- no serialization or deserialization is needed. The `JSON` and `JSONProxy` types work transparently with these providers; the marshaling layer simply passes the objects through.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meadow",
-  "version": "2.0.27",
+  "version": "2.0.29",
   "description": "A data access library.",
   "main": "source/Meadow.js",
   "scripts": {
@@ -9,6 +9,7 @@
     "test": "npx quack test",
     "tests": "npx quack test -g",
     "build": "npx quack build",
+    "prepublishOnly": "npm run build",
     "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",
@@ -86,22 +87,22 @@
     "gulp-util": "^3.0.8",
     "meadow-connection-dgraph": "^1.0.2",
     "meadow-connection-mongodb": "^1.0.2",
-    "meadow-connection-mssql": "^1.0.15",
-    "meadow-connection-mysql": "^1.0.13",
-    "meadow-connection-postgresql": "^1.0.1",
+    "meadow-connection-mssql": "^1.0.16",
+    "meadow-connection-mysql": "^1.0.14",
+    "meadow-connection-postgresql": "^1.0.2",
     "meadow-connection-rocksdb": "^0.0.2",
     "meadow-connection-solr": "^1.0.2",
-    "meadow-connection-sqlite": "^1.0.17",
-    "meadow-connection-sqlite-browser": "^1.0.0",
+    "meadow-connection-sqlite": "^1.0.18",
+    "meadow-connection-sqlite-browser": "^1.0.1",
     "mongodb": "^6.12.0",
     "mysql2": "^3.18.2",
     "puppeteer": "^24.38.0",
-    "quackage": "^1.0.60",
+    "quackage": "^1.0.63",
     "solr-client": "^0.9.0"
   },
   "dependencies": {
     "async": "3.2.6",
-    "foxhound": "^2.0.22",
+    "foxhound": "^2.0.25",
     "is-my-json-valid": "2.20.6",
     "simple-get": "^4.0.1"
   }

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

@@ -92,6 +92,12 @@ var MeadowProvider = function()
 						case 'Text':
 							tmpCreateStatement += "        `"+tmpSchema[j].Column+"` TEXT";
 							break;
+						case 'JSON':
+							tmpCreateStatement += "        `"+tmpSchema[j].Column+"` TEXT";
+							break;
+						case 'JSONProxy':
+							tmpCreateStatement += "        `"+tmpSchema[j].StorageColumn+"` TEXT";
+							break;
 						case 'CreateDate':
 						case 'UpdateDate':
 						case 'DeleteDate':
@@ -145,14 +151,63 @@ var MeadowProvider = function()
 			return true;
 		};
 
-		// The Meadow marshaller also passes in the Schema as the third parameter, but this is a blunt function ATM.
-		var marshalRecordFromSourceToObject = function(pObject, pRecord)
+		// The Meadow marshaller passes in the Schema as the third parameter for JSON/JSONProxy deserialization.
+		var marshalRecordFromSourceToObject = function (pObject, pRecord, pSchema)
 		{
-			// For now, crudely assign everything in pRecord to pObject
-			// This is safe in this context, and we don't want to slow down marshalling with millions of hasOwnProperty checks
-			for(var tmpColumn in pRecord)
+			// Build lookups for JSON columns (only if schema is provided)
+			var tmpJsonColumns = {};
+			var tmpProxyColumns = {};
+			if (Array.isArray(pSchema))
 			{
-				pObject[tmpColumn] = pRecord[tmpColumn];
+				for (var s = 0; s < pSchema.length; s++)
+				{
+					if (pSchema[s].Type === 'JSON')
+					{
+						tmpJsonColumns[pSchema[s].Column] = true;
+					}
+					else if (pSchema[s].Type === 'JSONProxy' && pSchema[s].StorageColumn)
+					{
+						tmpProxyColumns[pSchema[s].StorageColumn] = pSchema[s].Column;
+					}
+				}
+			}
+
+			for (var tmpColumn in pRecord)
+			{
+				if (tmpJsonColumns[tmpColumn])
+				{
+					// JSON type: parse string from DB into object on the same column name
+					try
+					{
+						pObject[tmpColumn] = (typeof pRecord[tmpColumn] === 'string')
+							? JSON.parse(pRecord[tmpColumn])
+							: (pRecord[tmpColumn] || {});
+					}
+					catch (pParseError)
+					{
+						pObject[tmpColumn] = {};
+					}
+				}
+				else if (tmpProxyColumns.hasOwnProperty(tmpColumn))
+				{
+					// JSONProxy: storage column -> parse and assign to virtual column name
+					var tmpVirtualColumn = tmpProxyColumns[tmpColumn];
+					try
+					{
+						pObject[tmpVirtualColumn] = (typeof pRecord[tmpColumn] === 'string')
+							? JSON.parse(pRecord[tmpColumn])
+							: (pRecord[tmpColumn] || {});
+					}
+					catch (pParseError)
+					{
+						pObject[tmpVirtualColumn] = {};
+					}
+					// Do NOT copy the storage column to the output object
+				}
+				else
+				{
+					pObject[tmpColumn] = pRecord[tmpColumn];
+				}
 			}
 		};
 

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

@@ -43,14 +43,63 @@ var MeadowProvider = function ()
 			return false;
 		}
 
-		// The Meadow marshaller also passes in the Schema as the third parameter, but this is a blunt function ATM.
-		var marshalRecordFromSourceToObject = function (pObject, pRecord)
+		// The Meadow marshaller passes in the Schema as the third parameter for JSON/JSONProxy deserialization.
+		var marshalRecordFromSourceToObject = function (pObject, pRecord, pSchema)
 		{
-			// For now, crudely assign everything in pRecord to pObject
-			// This is safe in this context, and we don't want to slow down marshalling with millions of hasOwnProperty checks
+			// Build lookups for JSON columns (only if schema is provided)
+			var tmpJsonColumns = {};
+			var tmpProxyColumns = {};
+			if (Array.isArray(pSchema))
+			{
+				for (var s = 0; s < pSchema.length; s++)
+				{
+					if (pSchema[s].Type === 'JSON')
+					{
+						tmpJsonColumns[pSchema[s].Column] = true;
+					}
+					else if (pSchema[s].Type === 'JSONProxy' && pSchema[s].StorageColumn)
+					{
+						tmpProxyColumns[pSchema[s].StorageColumn] = pSchema[s].Column;
+					}
+				}
+			}
+
 			for (var tmpColumn in pRecord)
 			{
-				pObject[tmpColumn] = pRecord[tmpColumn];
+				if (tmpJsonColumns[tmpColumn])
+				{
+					// JSON type: parse string from DB into object on the same column name
+					try
+					{
+						pObject[tmpColumn] = (typeof pRecord[tmpColumn] === 'string')
+							? JSON.parse(pRecord[tmpColumn])
+							: (pRecord[tmpColumn] || {});
+					}
+					catch (pParseError)
+					{
+						pObject[tmpColumn] = {};
+					}
+				}
+				else if (tmpProxyColumns.hasOwnProperty(tmpColumn))
+				{
+					// JSONProxy: storage column -> parse and assign to virtual column name
+					var tmpVirtualColumn = tmpProxyColumns[tmpColumn];
+					try
+					{
+						pObject[tmpVirtualColumn] = (typeof pRecord[tmpColumn] === 'string')
+							? JSON.parse(pRecord[tmpColumn])
+							: (pRecord[tmpColumn] || {});
+					}
+					catch (pParseError)
+					{
+						pObject[tmpVirtualColumn] = {};
+					}
+					// Do NOT copy the storage column to the output object
+				}
+				else
+				{
+					pObject[tmpColumn] = pRecord[tmpColumn];
+				}
 			}
 		};
 

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

@@ -116,13 +116,25 @@ var MeadowProvider = function()
 					pResponse.on('end', ()=>
 						{
 							if (tmpData)
-								tmpResult.value = JSON.parse(tmpData);
+							{
+								try
+								{
+									tmpResult.value = JSON.parse(tmpData);
+								}
+								catch (pParseError)
+								{
+									tmpResult.error = new Error(`Failed to parse Create response as JSON: ${pParseError.message}`);
+									return fCallback();
+								}
+							}
 
 							// TODO Because this was proxied, read happens at this layer too.  Inefficient -- fixable
-							let tmpIdentityColumn = `ID${pQuery.parameters.scope}`;
-							if (tmpResult.value.hasOwnProperty(tmpIdentityColumn))
-							tmpResult.value = tmpResult.value[tmpIdentityColumn];
-							
+							const tmpIdentityColumn = `ID${pQuery.parameters.scope}`;
+							if (tmpResult.value && tmpResult.value.hasOwnProperty(tmpIdentityColumn))
+							{
+								tmpResult.value = tmpResult.value[tmpIdentityColumn];
+							}
+
 							if (pQuery.logLevel > 0 ||
 								_GlobalLogLevel > 0)
 							{
@@ -169,7 +181,17 @@ var MeadowProvider = function()
 					pResponse.on('end', ()=>
 						{
 							if (tmpData)
-								tmpResult.value = JSON.parse(tmpData);
+							{
+								try
+								{
+									tmpResult.value = JSON.parse(tmpData);
+								}
+								catch (pParseError)
+								{
+									tmpResult.error = new Error(`Failed to parse Read response as JSON: ${pParseError.message}`);
+									return fCallback();
+								}
+							}
 
 							if (pQuery.query.body.startsWith(`${pQuery.parameters.scope}/`))
 							{
@@ -232,13 +254,23 @@ var MeadowProvider = function()
 					pResponse.on('end', ()=>
 						{
 							if (tmpData)
-								tmpResult.value = JSON.parse(tmpData);
+							{
+								try
+								{
+									tmpResult.value = JSON.parse(tmpData);
+								}
+								catch (pParseError)
+								{
+									tmpResult.error = new Error(`Failed to parse Update response as JSON: ${pParseError.message}`);
+									return fCallback();
+								}
+							}
+
+							// Keep result.value as the full response object so the
+							// Meadow Update waterfall's typeof check passes (it expects
+							// an object). The subsequent Read step uses the existing
+							// filters to re-read the updated record.
 
-							// TODO Because this was proxied, read happens at this layer too.  Inefficient -- fixable
-							let tmpIdentityColumn = `ID${pQuery.parameters.scope}`;
-							if (tmpResult.value.hasOwnProperty(tmpIdentityColumn))
-							tmpResult.value = tmpResult.value[tmpIdentityColumn];
-							
 							if (pQuery.logLevel > 0 ||
 								_GlobalLogLevel > 0)
 							{
@@ -284,11 +316,22 @@ var MeadowProvider = function()
 					pResponse.on('end', ()=>
 						{
 							if (tmpData)
-								tmpResult.value = JSON.parse(tmpData);
-							
-							if (tmpResult.value.hasOwnProperty('Count'))
+							{
+								try
+								{
+									tmpResult.value = JSON.parse(tmpData);
+								}
+								catch (pParseError)
+								{
+									tmpResult.error = new Error(`Failed to parse Delete response as JSON: ${pParseError.message}`);
+									return fCallback();
+								}
+							}
+
+							if (tmpResult.value && tmpResult.value.hasOwnProperty('Count'))
+							{
 								tmpResult.value = tmpResult.value.Count;
-	
+							}
 
 							if (pQuery.logLevel > 0 ||
 								_GlobalLogLevel > 0)
@@ -334,19 +377,29 @@ var MeadowProvider = function()
 					pResponse.on('end', ()=>
 						{
 							if (tmpData)
-								tmpResult.value = JSON.parse(tmpData);
-
+							{
 								try
 								{
-									tmpResult.value = tmpResult.value.Count;
+									tmpResult.value = JSON.parse(tmpData);
 								}
-								catch(pErrorGettingRowcount)
+								catch (pParseError)
 								{
-									// This is an error state...
-									tmpResult.value = -1;
-									_Fable.log.warn('Error getting rowcount during count query',{Body:pQuery.query.body, Parameters:pQuery.query.parameters});
+									tmpResult.error = new Error(`Failed to parse Count response as JSON: ${pParseError.message}`);
+									return fCallback();
 								}
-		
+							}
+
+							try
+							{
+								tmpResult.value = tmpResult.value.Count;
+							}
+							catch(pErrorGettingRowcount)
+							{
+								// This is an error state...
+								tmpResult.value = -1;
+								_Fable.log.warn('Error getting rowcount during count query',{Body:pQuery.query.body, Parameters:pQuery.query.parameters});
+							}
+
 							if (pQuery.logLevel > 0 ||
 								_GlobalLogLevel > 0)
 							{

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

@@ -57,14 +57,63 @@ var MeadowProvider = function ()
 			return false;
 		}
 
-		// The Meadow marshaller also passes in the Schema as the third parameter, but this is a blunt function ATM.
-		var marshalRecordFromSourceToObject = function (pObject, pRecord)
+		// The Meadow marshaller passes in the Schema as the third parameter for JSON/JSONProxy deserialization.
+		var marshalRecordFromSourceToObject = function (pObject, pRecord, pSchema)
 		{
-			// For now, crudely assign everything in pRecord to pObject
-			// This is safe in this context, and we don't want to slow down marshalling with millions of hasOwnProperty checks
+			// Build lookups for JSON columns (only if schema is provided)
+			var tmpJsonColumns = {};
+			var tmpProxyColumns = {};
+			if (Array.isArray(pSchema))
+			{
+				for (var s = 0; s < pSchema.length; s++)
+				{
+					if (pSchema[s].Type === 'JSON')
+					{
+						tmpJsonColumns[pSchema[s].Column] = true;
+					}
+					else if (pSchema[s].Type === 'JSONProxy' && pSchema[s].StorageColumn)
+					{
+						tmpProxyColumns[pSchema[s].StorageColumn] = pSchema[s].Column;
+					}
+				}
+			}
+
 			for (var tmpColumn in pRecord)
 			{
-				pObject[tmpColumn] = pRecord[tmpColumn];
+				if (tmpJsonColumns[tmpColumn])
+				{
+					// JSON type: parse string from DB into object on the same column name
+					try
+					{
+						pObject[tmpColumn] = (typeof pRecord[tmpColumn] === 'string')
+							? JSON.parse(pRecord[tmpColumn])
+							: (pRecord[tmpColumn] || {});
+					}
+					catch (pParseError)
+					{
+						pObject[tmpColumn] = {};
+					}
+				}
+				else if (tmpProxyColumns.hasOwnProperty(tmpColumn))
+				{
+					// JSONProxy: storage column -> parse and assign to virtual column name
+					var tmpVirtualColumn = tmpProxyColumns[tmpColumn];
+					try
+					{
+						pObject[tmpVirtualColumn] = (typeof pRecord[tmpColumn] === 'string')
+							? JSON.parse(pRecord[tmpColumn])
+							: (pRecord[tmpColumn] || {});
+					}
+					catch (pParseError)
+					{
+						pObject[tmpVirtualColumn] = {};
+					}
+					// Do NOT copy the storage column to the output object
+				}
+				else
+				{
+					pObject[tmpColumn] = pRecord[tmpColumn];
+				}
 			}
 		};