@carbonorm/carbonnode 6.0.10 → 6.0.13

package/src/__tests__/sakila-db/sqlResponses/C6.rental.post.json

@@ -3,14 +3,14 @@
   "insertId": 16050,
   "rest": [],
   "sql": {
-    "sql": "INSERT INTO `rental` (\n            `rental_date`, `inventory_id`, `customer_id`, `return_date`, `staff_id`, `last_update`\n         ) VALUES (\n            ?, ?, ?, ?, ?, ?\n        )",
+    "sql": "INSERT INTO `rental` (\n            `rental_date`, `inventory_id`, `customer_id`, `return_date`, `staff_id`, `last_update`\n         ) VALUES\n            (?, ?, ?, ?, ?, ?)",
     "values": [
-      "2026-02-06 05:58:33",
+      "2026-02-08 19:33:00",
       1,
       1,
-      "2026-02-06 05:58:33",
+      "2026-02-08 19:33:00",
       1,
-      "2026-02-06 05:58:33"
+      "2026-02-08 19:33:00"
     ]
   }
 }

package/src/__tests__/sakila-db/sqlResponses/C6.rental.post.latest.json

@@ -2,12 +2,12 @@
   "rest": [
     {
       "rental_id": 16050,
-      "rental_date": "2026-02-06T05:58:33.000Z",
+      "rental_date": "2026-02-08T19:33:00.000Z",
       "inventory_id": 1,
       "customer_id": 1,
-      "return_date": "2026-02-06T05:58:33.000Z",
+      "return_date": "2026-02-08T19:33:00.000Z",
       "staff_id": 1,
-      "last_update": "2026-02-06T05:58:33.000Z"
+      "last_update": "2026-02-08T19:33:00.000Z"
     }
   ],
   "sql": {

package/src/__tests__/sakila-db/sqlResponses/C6.rental.put.json

@@ -5,7 +5,7 @@
   "sql": {
     "sql": "UPDATE `rental` SET `rental_date` = ? WHERE (rental.rental_id) = ?",
     "values": [
-      "2026-02-06 05:58:33",
+      "2026-02-08 19:33:00",
       16050
     ]
   }

package/src/__tests__/sakila-db/sqlResponses/C6.rental.put.lookup.json

@@ -2,12 +2,12 @@
   "rest": [
     {
       "rental_id": 16050,
-      "rental_date": "2026-02-06T05:58:33.000Z",
+      "rental_date": "2026-02-08T19:33:00.000Z",
       "inventory_id": 1,
       "customer_id": 1,
-      "return_date": "2026-02-06T05:58:33.000Z",
+      "return_date": "2026-02-08T19:33:00.000Z",
       "staff_id": 1,
-      "last_update": "2026-02-06T05:58:33.000Z"
+      "last_update": "2026-02-08T19:33:00.000Z"
     }
   ],
   "sql": {

package/src/__tests__/sakila.generated.test.ts

@@ -14,10 +14,18 @@ describe('sakila-db generated C6 bindings', () => {
   beforeAll(() => {
     // Provide a mocked MySQL pool so SqlExecutor path is used without a real DB
     const mockConn = {
-      query: vi.fn().mockImplementation(async (_sql: string, _values?: any[]) => {
-        // Return a result set shaped like mysql2/promise: [rows, fields]
-        return [[{ ok: true }], []];
+      query: vi.fn().mockImplementation(async (sql: string, _values?: any[]) => {
+        const statement = sql.trim().toUpperCase();
+        if (statement.startsWith("SELECT")) {
+          // Return a result set shaped like mysql2/promise: [rows, fields]
+          return [[{ ok: true }], []];
+        }
+        // Return a write result for POST/PUT/DELETE shaped like mysql2/promise
+        return [{ affectedRows: 1, insertId: 9999 }, []];
       }),
+      beginTransaction: vi.fn().mockResolvedValue(undefined),
+      commit: vi.fn().mockResolvedValue(undefined),
+      rollback: vi.fn().mockResolvedValue(undefined),
       release: vi.fn()
     };
 

package/src/__tests__/sqlBuilders.test.ts

@@ -96,6 +96,52 @@ describe('SQL Builders', () => {
     expect(params).toEqual([JSON.stringify(payload)]);
   });
 
+  it('builds multi-row INSERT from dataInsertMultipleRows', () => {
+    const config = buildTestConfig();
+    const qb = new PostQueryBuilder(config as any, {
+      dataInsertMultipleRows: [
+        {
+          'actor.first_name': 'ALICE',
+          'actor.last_name': 'ONE',
+        },
+        {
+          'actor.first_name': 'BOB',
+          'actor.last_name': 'TWO',
+        },
+      ],
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('INSERT INTO `actor`');
+    expect(sql).toContain('`first_name`, `last_name`');
+    expect(sql).toContain(') VALUES');
+    expect(sql).toContain('),');
+    expect(params).toEqual(['ALICE', 'ONE', 'BOB', 'TWO']);
+  });
+
+  it('builds multi-row INSERT from direct array request syntax', () => {
+    const config = buildTestConfig();
+    const qb = new PostQueryBuilder(config as any, [
+      {
+        'actor.first_name': 'ALICE',
+        'actor.last_name': 'ONE',
+      },
+      {
+        'actor.first_name': 'BOB',
+        'actor.last_name': 'TWO',
+      },
+    ] as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('INSERT INTO `actor`');
+    expect(sql).toContain('`first_name`, `last_name`');
+    expect(sql).toContain(') VALUES');
+    expect(sql).toContain('),');
+    expect(params).toEqual(['ALICE', 'ONE', 'BOB', 'TWO']);
+  });
+
   it('stringifies dotted-key JSON payloads for JSON columns on UPDATE', () => {
     const config = buildTestConfig();
     const payload = { 'section1.preparedBy': 'Prepared by Assessorly, Co.' };

package/src/__tests__/sqlExecutorLifecycleHooks.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it, vi } from 'vitest';
+import { SqlExecutor } from '../executors/SqlExecutor';
+import { PostQueryBuilder } from '../orm/queries/PostQueryBuilder';
+
+describe('SqlExecutor lifecycle hooks', () => {
+  it('runs beforeExecution/afterExecution around query and afterCommit after commit', async () => {
+    const hookOrder: string[] = [];
+    let afterExecutionArgs: any;
+    let afterCommitArgs: any;
+
+    const conn: any = {
+      beginTransaction: vi.fn(async () => {
+        hookOrder.push('begin');
+      }),
+      query: vi.fn(async () => {
+        hookOrder.push('query');
+        return [{ affectedRows: 1, insertId: 42 }, []];
+      }),
+      commit: vi.fn(async () => {
+        hookOrder.push('commit');
+      }),
+      rollback: vi.fn(async () => {
+        hookOrder.push('rollback');
+      }),
+      release: vi.fn(),
+    };
+
+    const config: any = {
+      requestMethod: 'POST',
+      mysqlPool: {
+        getConnection: vi.fn(async () => conn),
+      },
+      websocketBroadcast: vi.fn(async () => {
+        hookOrder.push('broadcast');
+      }),
+      C6: {
+        PREFIX: '',
+      },
+      restModel: {
+        TABLE_NAME: 'widgets',
+        PRIMARY: ['widgets.id'],
+        PRIMARY_SHORT: ['id'],
+        COLUMNS: {
+          'widgets.id': 'id',
+          'widgets.name': 'name',
+        },
+        LIFECYCLE_HOOKS: {
+          GET: {},
+          POST: {
+            beforeProcessing: {
+              first: async ({ request }: any) => {
+                hookOrder.push('beforeProcessing');
+                request.seed = 'from-before-processing';
+              },
+            },
+            beforeExecution: {
+              second: async ({ request }: any) => {
+                hookOrder.push('beforeExecution');
+                request.stage = 'from-before-execution';
+              },
+            },
+            afterExecution: {
+              third: async (args: any) => {
+                hookOrder.push('afterExecution');
+                afterExecutionArgs = args;
+                expect(conn.commit).toHaveBeenCalledTimes(0);
+              },
+            },
+            afterCommit: {
+              fourth: async (args: any) => {
+                hookOrder.push('afterCommit');
+                afterCommitArgs = args;
+                expect(conn.commit).toHaveBeenCalledTimes(1);
+              },
+            },
+          },
+          PUT: {},
+          DELETE: {},
+        },
+      },
+    };
+
+    const request: any = { name: 'example' };
+
+    vi.spyOn(PostQueryBuilder.prototype as any, 'build').mockReturnValue({
+      sql: 'INSERT INTO widgets (name) VALUES (:name)',
+      params: { name: 'example' },
+    });
+
+    const executor = new SqlExecutor<any>(config, request);
+
+    const result = await executor.execute();
+
+    expect(result).toMatchObject({
+      affected: 1,
+      insertId: 42,
+    });
+    expect(hookOrder).toEqual([
+      'beforeProcessing',
+      'begin',
+      'beforeExecution',
+      'query',
+      'afterExecution',
+      'commit',
+      'afterCommit',
+      'broadcast',
+    ]);
+
+    expect((executor as any).request.seed).toBe('from-before-processing');
+    expect((executor as any).request.stage).toBe('from-before-execution');
+
+    expect(afterExecutionArgs.response.data.success).toBe(true);
+    expect(afterExecutionArgs.response.data.insertId).toBe(42);
+    expect(afterExecutionArgs.response.data.affected).toBe(1);
+
+    expect(afterCommitArgs.response.data.success).toBe(true);
+    expect(afterCommitArgs.response.data.insertId).toBe(42);
+    expect(afterCommitArgs.response.data.affected).toBe(1);
+
+    expect(conn.rollback).not.toHaveBeenCalled();
+  });
+});

package/src/api/convertForRequestBody.ts

@@ -11,7 +11,11 @@ export default function <
     restfulObject: RequestQueryBody<RequestMethod, RestTableInterface, CustomAndRequiredFields, RequestTableOverrides>,
     tableName: string | string[],
     C6: iC6Object,
-    regexErrorHandler: (message: string) => void = alert
+    regexErrorHandler: (message: string) => void = (message: string) => {
+        if (typeof globalThis !== "undefined" && typeof (globalThis as any).alert === "function") {
+            (globalThis as any).alert(message);
+        }
+    }
 ) {
     const payload: Record<string, any> = {};
     const tableNames = Array.isArray(tableName) ? tableName : [tableName];
@@ -43,7 +47,8 @@ export default function <
                 C6Constants.DELETE,
                 C6Constants.WHERE,
                 C6Constants.JOIN,
-                C6Constants.PAGINATION
+                C6Constants.PAGINATION,
+                "cacheResults",
             ].includes(value)) {
                 const val = restfulObject[value];
                 if (Array.isArray(val)) {
@@ -52,6 +57,8 @@ export default function <
                     payload[value] = Object.keys(val)
                         .sort()
                         .reduce((acc, key) => ({ ...acc, [key]: val[key] }), {});
+                } else {
+                    payload[value] = val;
                 }
                 continue;
             }

package/src/api/restRequest.ts

@@ -34,6 +34,7 @@ export default function restRequest<
         const config = typeof configX === "function" ? configX() : configX;
 
         applyLogLevelDefaults(config, request);
+
         const logContext = getLogContext(config, request);
 
         if (!config.mysqlPool && !config.axios) {

package/src/executors/HttpExecutor.ts

@@ -257,7 +257,7 @@ export class HttpExecutor<
             // literally impossible for query to be undefined or null here but the editor is too busy licking windows to understand that
             let querySerialized: string = sortAndSerializeQueryObject(tables, cacheRequestData ?? {});
 
-            let cachedRequest: AxiosPromise<ResponseDataType> | false = false;
+            let cachedRequest: Promise<{ data: ResponseDataType }> | false = false;
 
             if (cacheResults) {
                 cachedRequest = checkCache<ResponseDataType>(requestMethod, tableName, cacheRequestData);