@carbonorm/carbonnode 3.7.19 → 3.7.21

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, buildBinaryTestConfig } 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', () => {
@@ -178,5 +178,33 @@ describe('SQL Builders', () => {
     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/executors/HttpExecutor.ts

@@ -25,6 +25,15 @@ export class HttpExecutor<
 >
     extends Executor<G> {
 
+    private stripTableNameFromKeys(obj: Record<string, any>) {
+        const columns = (this.config.restModel as any).COLUMNS || {};
+        return Object.keys(obj || {}).reduce((acc: Record<string, any>, key) => {
+            const shortKey = columns[key] || key.split('.').pop();
+            acc[shortKey] = obj[key];
+            return acc;
+        }, {} as Record<string, any>);
+    }
+
     public putState(
         response: AxiosResponse<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>,
         request: RequestQueryBody<
@@ -35,11 +44,12 @@ export class HttpExecutor<
         >,
         callback: () => void
     ) {
+        const normalized = this.stripTableNameFromKeys(request as Record<string, any>);
         this.config.reactBootstrap?.updateRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: [
                 removeInvalidKeys<G['RestTableInterface']>({
-                    ...request,
+                    ...normalized,
                     ...response?.data?.rest,
                 }, this.config.C6.TABLES)
             ],
@@ -76,15 +86,16 @@ export class HttpExecutor<
         this.config.reactBootstrap?.updateRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: undefined !== request.dataInsertMultipleRows
-                ? request.dataInsertMultipleRows.map((request, index) => {
+                ? request.dataInsertMultipleRows.map((row, index) => {
+                    const normalizedRow = this.stripTableNameFromKeys(row);
                     return removeInvalidKeys<G['RestTableInterface']>({
-                        ...request,
+                        ...normalizedRow,
                         ...(index === 0 ? response?.data?.rest : {}),
                     }, this.config.C6.TABLES)
                 })
                 : [
                     removeInvalidKeys<G['RestTableInterface']>({
-                        ...request,
+                        ...this.stripTableNameFromKeys(request as Record<string, any>),
                         ...response?.data?.rest,
                     }, this.config.C6.TABLES)
                 ],
@@ -103,10 +114,11 @@ export class HttpExecutor<
         >,
         callback: () => void
     ) {
+        const normalized = this.stripTableNameFromKeys(request as Record<string, any>);
         this.config.reactBootstrap?.deleteRestfulObjectArrays<G['RestTableInterface']>({
             callback,
             dataOrCallback: [
-                request as unknown as G['RestTableInterface'],
+                removeInvalidKeys<G['RestTableInterface']>(normalized, this.config.C6.TABLES),
             ],
             stateKey: this.config.restModel.TABLE_NAME,
             uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof G['RestTableInterface'])[]
@@ -571,7 +583,8 @@ export class HttpExecutor<
                             switch (requestMethod) {
                                 case GET:
                                     response.data && reactBootstrap.updateRestfulObjectArrays<G['RestTableInterface']>({
-                                        dataOrCallback: Array.isArray(response.data.rest) ? response.data.rest : [response.data.rest],
+                                        dataOrCallback: (Array.isArray(response.data.rest) ? response.data.rest : [response.data.rest])
+                                            .map(r => this.stripTableNameFromKeys(r)),
                                         stateKey: this.config.restModel.TABLE_NAME,
                                         uniqueObjectId: this.config.restModel.PRIMARY_SHORT as (keyof G['RestTableInterface'])[],
                                         callback

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

@@ -104,7 +104,8 @@ export abstract class ConditionBuilder<
         if (typeof column === 'string' && column.includes('.')) {
             const [tableName, colName] = column.split('.', 2);
             const table = this.config.C6?.TABLES?.[tableName];
-            columnDef = table?.TYPE_VALIDATION?.[colName];
+            // 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);