@carbonorm/carbonnode 4.0.0 → 4.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonorm/carbonnode",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "browser": "dist/index.umd.js",
   "repository": {
     "type": "git",

package/src/__tests__/sakila-db/C6.js

@@ -1342,7 +1342,7 @@ export const TABLES = {
 };
 export const C6 = {
     ...C6Constants,
-    C6VERSION: '4.0.0',
+    C6VERSION: '4.0.1',
     IMPORT: async (tableName) => {
         tableName = tableName.toLowerCase();
         // if tableName is not a key in the TABLES object then throw an error

package/src/__tests__/sakila-db/C6.ts

@@ -2009,7 +2009,7 @@ export type RestTableInterfaces = iActor
 
 export const C6 : iC6Object<RestTableInterfaces> = {
     ...C6Constants,
-    C6VERSION: '4.0.0',
+    C6VERSION: '4.0.1',
     IMPORT: async (tableName: string) : Promise<iDynamicApiImport> => {
 
         tableName = tableName.toLowerCase();

package/src/__tests__/sqlBuilders.test.ts

@@ -76,6 +76,23 @@ describe('SQL Builders', () => {
     expect(params).toEqual([JSON.stringify(payload)]);
   });
 
+  it('stringifies dotted-key JSON payloads for JSON columns on UPDATE', () => {
+    const config = buildTestConfig();
+    const payload = { 'section1.preparedBy': 'Prepared by Assessorly, Co.' };
+    const qb = new UpdateQueryBuilder(config as any, {
+      [C6C.UPDATE]: {
+        'actor.json_data': payload,
+      },
+      WHERE: {
+        'actor.actor_id': [C6C.EQUAL, 5],
+      }
+    } as any, false);
+
+    const { params } = qb.build('actor');
+
+    expect(params).toEqual([JSON.stringify(payload), 5]);
+  });
+
   it('throws on operator-shaped insert payloads', () => {
     const config = buildTestConfig();
     const qb = new PostQueryBuilder(config as any, {

package/src/api/orm/builders/ConditionBuilder.ts

@@ -378,19 +378,19 @@ export abstract class ConditionBuilder<
         throw new Error('Unsupported operand type in SQL expression.');
     }
 
-    private isPlainArrayLiteral(value: any): boolean {
+    private isPlainArrayLiteral(value: any, allowColumnRefs = false): boolean {
         if (!Array.isArray(value)) return false;
         return value.every(item => {
             if (item === null) return true;
             const type = typeof item;
             if (type === 'string' || type === 'number' || type === 'boolean') return true;
-            if (Array.isArray(item)) return this.isPlainArrayLiteral(item);
-            if (item && typeof item === 'object') return this.isPlainObjectLiteral(item);
+            if (Array.isArray(item)) return this.isPlainArrayLiteral(item, allowColumnRefs);
+            if (item && typeof item === 'object') return this.isPlainObjectLiteral(item, allowColumnRefs);
             return false;
         });
     }
 
-    private isPlainObjectLiteral(value: any): boolean {
+    private isPlainObjectLiteral(value: any, allowColumnRefs = false): boolean {
         if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
         if (value instanceof Date) return false;
         if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value)) return false;
@@ -405,13 +405,30 @@ export abstract class ConditionBuilder<
             return false;
         }
 
-        if (entries.some(([key]) => typeof key === 'string' && (this.isColumnRef(key) || key.includes('.')))) {
-            return false;
+        if (!allowColumnRefs) {
+            if (entries.some(([key]) => typeof key === 'string' && (this.isColumnRef(key) || key.includes('.')))) {
+                return false;
+            }
         }
 
         return true;
     }
 
+    private resolveColumnDefinition(column?: string): any | undefined {
+        if (!column || typeof column !== 'string' || !column.includes('.')) return undefined;
+        const [prefix, colName] = column.split('.', 2);
+        const tableName = this.aliasMap[prefix] ?? prefix;
+        const table = this.config.C6?.TABLES?.[tableName];
+        if (!table?.TYPE_VALIDATION) return undefined;
+        return table.TYPE_VALIDATION[colName] ?? table.TYPE_VALIDATION[`${tableName}.${colName}`];
+    }
+
+    private isJsonColumn(column?: string): boolean {
+        const columnDef = this.resolveColumnDefinition(column);
+        const mysqlType = columnDef?.MYSQL_TYPE;
+        return typeof mysqlType === 'string' && mysqlType.toLowerCase().includes('json');
+    }
+
     protected serializeUpdateValue(
         value: any,
         params: any[] | Record<string, any>,
@@ -419,7 +436,10 @@ export abstract class ConditionBuilder<
     ): string {
         const normalized = value instanceof Map ? Object.fromEntries(value) : value;
 
-        if (this.isPlainArrayLiteral(normalized) || this.isPlainObjectLiteral(normalized)) {
+        const allowColumnRefs = this.isJsonColumn(contextColumn);
+
+        if (this.isPlainArrayLiteral(normalized, allowColumnRefs)
+            || this.isPlainObjectLiteral(normalized, allowColumnRefs)) {
             return this.addParam(params, contextColumn ?? '', JSON.stringify(normalized));
         }