@carbonorm/carbonnode 3.7.18 → 3.7.20

package/src/__tests__/sakila-db/sakila-schema.sql

@@ -684,3 +684,14 @@ SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;
 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;
 
 
+--
+-- Table structure for table `binary_test`
+--
+
+DROP TABLE IF EXISTS `binary_test`;
+
+CREATE TABLE `binary_test` (
+  `id` int NOT NULL AUTO_INCREMENT,
+  `bin_col` binary(16) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

package/src/__tests__/sqlBuilders.test.ts

@@ -4,7 +4,7 @@ import { SelectQueryBuilder } from '../api/orm/queries/SelectQueryBuilder';
 import { PostQueryBuilder } from '../api/orm/queries/PostQueryBuilder';
 import { UpdateQueryBuilder } from '../api/orm/queries/UpdateQueryBuilder';
 import { DeleteQueryBuilder } from '../api/orm/queries/DeleteQueryBuilder';
-import { buildTestConfig } from './fixtures/c6.fixture';
+import { buildTestConfig, buildBinaryTestConfig, buildBinaryTestConfigFqn } from './fixtures/c6.fixture';
 
 describe('SQL Builders', () => {
   it('builds SELECT with JOIN, WHERE, GROUP BY, HAVING and default LIMIT', () => {
@@ -135,5 +135,76 @@ describe('SQL Builders', () => {
     expect(Buffer.isBuffer(buf)).toBe(true);
     expect((buf as Buffer).length).toBe(16);
   });
-});
 
+  it('converts hex to Buffer for BINARY columns in INSERT params', () => {
+    const config = buildBinaryTestConfig();
+    const qb = new PostQueryBuilder(config as any, {
+      [C6C.INSERT]: {
+        'binary_test.bin_col': '0123456789abcdef0123456789abcdef'
+      }
+    } as any, false);
+
+    const { params } = qb.build('binary_test');
+    const buf = (params as any[])[0];
+    expect(Buffer.isBuffer(buf)).toBe(true);
+    expect((buf as Buffer).length).toBe(16);
+  });
+
+  it('converts hex to Buffer for BINARY columns in UPDATE params', () => {
+    const config = buildBinaryTestConfig();
+    const qb = new UpdateQueryBuilder(config as any, {
+      [C6C.UPDATE]: {
+        'binary_test.bin_col': '0123456789abcdef0123456789abcdef'
+      },
+      WHERE: { 'binary_test.id': [C6C.EQUAL, 1] }
+    } as any, false);
+
+    const { params } = qb.build('binary_test');
+    const buf = (params as any[])[0];
+    expect(Buffer.isBuffer(buf)).toBe(true);
+    expect((buf as Buffer).length).toBe(16);
+  });
+  it('converts hex to Buffer for BINARY columns in UPDATE params with unqualified column', () => {
+    const config = buildBinaryTestConfig();
+    const qb = new UpdateQueryBuilder(config as any, {
+      [C6C.UPDATE]: {
+        'bin_col': '0123456789abcdef0123456789abcdef'
+      },
+      WHERE: { 'binary_test.id': [C6C.EQUAL, 1] }
+    } as any, false);
+
+    const { params } = qb.build('binary_test');
+    const buf = (params as any[])[0];
+    expect(Buffer.isBuffer(buf)).toBe(true);
+    expect((buf as Buffer).length).toBe(16);
+  });
+
+  it('converts hex to Buffer for BINARY when TYPE_VALIDATION uses fully-qualified key (INSERT)', () => {
+    const config = buildBinaryTestConfigFqn();
+    const qb = new PostQueryBuilder(config as any, {
+      [C6C.INSERT]: {
+        'binary_test.bin_col': '0123456789abcdef0123456789abcdef'
+      }
+    } as any, false);
+
+    const { params } = qb.build('binary_test');
+    const buf = (params as any[])[0];
+    expect(Buffer.isBuffer(buf)).toBe(true);
+    expect((buf as Buffer).length).toBe(16);
+  });
+
+  it('converts hex to Buffer for BINARY when TYPE_VALIDATION uses fully-qualified key (UPDATE)', () => {
+    const config = buildBinaryTestConfigFqn();
+    const qb = new UpdateQueryBuilder(config as any, {
+      [C6C.UPDATE]: {
+        'binary_test.bin_col': 'ffffffffffffffffffffffffffffffff'
+      },
+      WHERE: { 'binary_test.id': [C6C.EQUAL, 1] }
+    } as any, false);
+
+    const { params } = qb.build('binary_test');
+    const buf = (params as any[])[0];
+    expect(Buffer.isBuffer(buf)).toBe(true);
+    expect((buf as Buffer).length).toBe(16);
+  });
+});

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

@@ -102,9 +102,10 @@ export abstract class ConditionBuilder<
         // Determine column definition from C6.TABLES to support type-aware conversions (e.g., BINARY hex -> Buffer)
         let columnDef: any | undefined;
         if (typeof column === 'string' && column.includes('.')) {
-            const [tableName] = column.split('.', 2);
+            const [tableName, colName] = column.split('.', 2);
             const table = this.config.C6?.TABLES?.[tableName];
-            columnDef = table?.TYPE_VALIDATION?.[column];
+            // Support both short-keyed and fully-qualified TYPE_VALIDATION entries
+            columnDef = table?.TYPE_VALIDATION?.[colName] ?? table?.TYPE_VALIDATION?.[`${tableName}.${colName}`];
         }
         const val = convertHexIfBinary(column, value, columnDef);
 

package/src/api/orm/queries/UpdateQueryBuilder.ts

@@ -31,7 +31,11 @@ export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
         }
 
         const setClauses = Object.entries(this.request[C6C.UPDATE])
-            .map(([col, val]) => `\`${this.trimTablePrefix(table, col)}\` = ${this.addParam(params, col, val)}`);
+            .map(([col, val]) => {
+                const trimmed = this.trimTablePrefix(table, col);
+                const qualified = `${table}.${trimmed}`;
+                return `\`${trimmed}\` = ${this.addParam(params, qualified, val)}`;
+            });
 
         sql += ` SET ${setClauses.join(', ')}`;