@carbonorm/carbonnode 6.0.13 → 6.0.17

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

@@ -5,8 +5,8 @@
   "sql": {
     "sql": "INSERT INTO `language` (\n            `name`, `last_update`\n         ) VALUES\n            (?, ?)",
     "values": [
-      "name_1770579180037",
-      "2026-02-08 19:33:00"
+      "name_1770923648022",
+      "2026-02-12 19:14:08"
     ]
   }
 }

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

@@ -2,8 +2,8 @@
   "rest": [
     {
       "language_id": 7,
-      "name": "name_1770579180037",
-      "last_update": "2026-02-08T19:33:00.000Z"
+      "name": "name_1770923648022",
+      "last_update": "2026-02-12T19:14:08.000Z"
     }
   ],
   "sql": {

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

@@ -5,7 +5,7 @@
   "sql": {
     "sql": "UPDATE `language` SET `name` = ? WHERE (language.language_id) = ?",
     "values": [
-      "name_updated_1770579",
+      "name_updated_1770923",
       7
     ]
   }

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

@@ -2,8 +2,8 @@
   "rest": [
     {
       "language_id": 7,
-      "name": "name_updated_1770579",
-      "last_update": "2026-02-08T19:33:00.000Z"
+      "name": "name_updated_1770923",
+      "last_update": "2026-02-12T19:14:08.000Z"
     }
   ],
   "sql": {

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

@@ -9,8 +9,8 @@
       1,
       1,
       1,
-      "2026-02-08 19:33:00",
-      "2026-02-08 19:33:00"
+      "2026-02-12 19:14:08",
+      "2026-02-12 19:14:08"
     ]
   }
 }

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

@@ -6,8 +6,8 @@
       "staff_id": 1,
       "rental_id": 1,
       "amount": "1.00",
-      "payment_date": "2026-02-08T19:33:00.000Z",
-      "last_update": "2026-02-08T19:33:00.000Z"
+      "payment_date": "2026-02-12T19:14:08.000Z",
+      "last_update": "2026-02-12T19:14:08.000Z"
     }
   ],
   "sql": {

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

@@ -6,8 +6,8 @@
       "staff_id": 1,
       "rental_id": 1,
       "amount": "1.00",
-      "payment_date": "2026-02-08T19:33:00.000Z",
-      "last_update": "2026-02-08T19:33:00.000Z"
+      "payment_date": "2026-02-12T19:14:08.000Z",
+      "last_update": "2026-02-12T19:14:08.000Z"
     }
   ],
   "sql": {

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

@@ -1,18 +1,18 @@
 {
   "rest": [
     {
-      "rental_id": 1,
-      "rental_date": "2005-05-24T22:53:30.000Z",
-      "inventory_id": 367,
-      "customer_id": 130,
-      "return_date": "2005-05-26T22:04:30.000Z",
-      "staff_id": 1,
+      "rental_id": 76,
+      "rental_date": "2005-05-25T11:30:37.000Z",
+      "inventory_id": 3021,
+      "customer_id": 1,
+      "return_date": "2005-06-03T12:00:37.000Z",
+      "staff_id": 2,
       "last_update": "2006-02-15T04:57:20.000Z",
       "store_id": 1,
-      "first_name": "CHARLOTTE",
-      "last_name": "HUNTER",
-      "email": "CHARLOTTE.HUNTER@sakilacustomer.org",
-      "address_id": 134,
+      "first_name": "MARY",
+      "last_name": "SMITH",
+      "email": "MARY.SMITH@sakilacustomer.org",
+      "address_id": 5,
       "active": 1,
       "create_date": "2006-02-14T22:04:36.000Z"
     }

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

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

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

@@ -2,12 +2,12 @@
   "rest": [
     {
       "rental_id": 16050,
-      "rental_date": "2026-02-08T19:33:00.000Z",
+      "rental_date": "2026-02-12T19:14:08.000Z",
       "inventory_id": 1,
       "customer_id": 1,
-      "return_date": "2026-02-08T19:33:00.000Z",
+      "return_date": "2026-02-12T19:14:08.000Z",
       "staff_id": 1,
-      "last_update": "2026-02-08T19:33:00.000Z"
+      "last_update": "2026-02-12T19:14:08.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-08 19:33:00",
+      "2026-02-12 19:14:08",
       16050
     ]
   }

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

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

package/src/__tests__/sqlAllowList.test.ts

@@ -119,10 +119,110 @@ describe("SQL allowlist", () => {
       await expect(
         Actor.Get({
           [C6.PAGINATION]: {[C6.LIMIT]: 1},
+          cacheResults: false,
         } as any)
       ).rejects.toThrow("SQL statement is not permitted");
     } finally {
       restoreGlobals(originalGlobals);
     }
   });
+
+  it("normalizes multi-row VALUES with variable row counts", () => {
+    const oneRow = `
+      INSERT INTO \`valuation_report_comparables\` (\`report_id\`, \`unit_id\`, \`subject_unit_id\`)
+      VALUES (?, ?, ?)
+      ON DUPLICATE KEY UPDATE \`subject_unit_id\` = VALUES(\`subject_unit_id\`)
+    `;
+    const manyRows = `
+      INSERT INTO \`valuation_report_comparables\` (\`report_id\`, \`unit_id\`, \`subject_unit_id\`)
+      VALUES (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?)
+      ON DUPLICATE KEY UPDATE \`subject_unit_id\` = VALUES(\`subject_unit_id\`)
+    `;
+
+    expect(normalizeSql(oneRow)).toContain("VALUES (? ×3) ×*");
+    expect(normalizeSql(manyRows)).toContain("VALUES (? ×3) ×*");
+    expect(normalizeSql(oneRow)).toBe(normalizeSql(manyRows));
+  });
+
+  it("normalizes IN bind list cardinality", () => {
+    const smallIn = "SELECT * FROM `geometries` WHERE ( geometries.geometry_id IN (?, ?, ?) ) LIMIT 100";
+    const largeIn = "SELECT * FROM `geometries` WHERE ( geometries.geometry_id IN (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ) LIMIT 250";
+
+    const normalizedSmall = normalizeSql(smallIn);
+    const normalizedLarge = normalizeSql(largeIn);
+
+    expect(normalizedSmall).toContain("IN (? ×*)");
+    expect(normalizedLarge).toContain("IN (? ×*)");
+    expect(normalizedSmall).toContain("LIMIT ?");
+    expect(normalizedLarge).toContain("LIMIT ?");
+    expect(normalizedSmall).toBe(normalizedLarge);
+  });
+
+  it("normalizes LIMIT and OFFSET numeric literals", () => {
+    expect(normalizeSql("SELECT * FROM `actor` LIMIT 100")).toBe(
+      normalizeSql("SELECT * FROM `actor` LIMIT 25"),
+    );
+    expect(normalizeSql("SELECT * FROM `actor` LIMIT 10, 50")).toBe(
+      "SELECT * FROM `actor` LIMIT ?, ?",
+    );
+    expect(normalizeSql("SELECT * FROM `actor` LIMIT 50 OFFSET 100")).toBe(
+      "SELECT * FROM `actor` LIMIT ? OFFSET ?",
+    );
+  });
+
+  it("normalizes variable ST_GEOMFROMTEXT POINT and POLYGON literals", () => {
+    const q1 = `
+      SELECT * FROM \`property_units\`
+      WHERE MBRCONTAINS(
+        ST_GEOMFROMTEXT('POLYGON((39.1 -105.1, 39.2 -105.1, 39.2 -105.0, 39.1 -105.0, 39.1 -105.1))', 4326),
+        property_units.location
+      )
+      ORDER BY ST_DISTANCE_SPHERE(
+        property_units.location,
+        ST_GEOMFROMTEXT('POINT(39.15 -105.05)', 4326)
+      )
+      LIMIT 100
+    `;
+    const q2 = `
+      SELECT * FROM \`property_units\`
+      WHERE MBRCONTAINS(
+        ST_GEOMFROMTEXT('POLYGON((39.3 -105.3, 39.7 -105.3, 39.7 -104.8, 39.3 -104.8, 39.3 -105.3))', 4326),
+        property_units.location
+      )
+      ORDER BY ST_DISTANCE_SPHERE(
+        property_units.location,
+        ST_GEOMFROMTEXT('POINT(39.5321821 -105.0035613)', 4326)
+      )
+      LIMIT 250
+    `;
+
+    const normalized1 = normalizeSql(q1);
+    const normalized2 = normalizeSql(q2);
+
+    expect(normalized1).toContain("ST_GEOMFROMTEXT('POLYGON((?))', ?)");
+    expect(normalized1).toContain("ST_GEOMFROMTEXT('POINT(? ?)', ?)");
+    expect(normalized1).toContain("ST_DISTANCE_SPHERE(");
+    expect(normalized1).toContain("LIMIT ?");
+    expect(normalized1).toBe(normalized2);
+  });
+
+  it("normalizes geo function casing and FORCE INDEX spacing", () => {
+    const a =
+      "SELECT * FROM `property_units` FORCE INDEX (`idx_county_id`,`idx_property_units_location`) WHERE ST_Distance_Sphere(property_units.location, ST_GeomFromText('POINT(39.5 -105.0)', 4326)) <= 50 LIMIT 100";
+    const b =
+      "SELECT * FROM `property_units` FORCE INDEX (`idx_county_id`, `idx_property_units_location`) WHERE st_distance_sphere(property_units.location, st_geomfromtext('POINT(39.7 -104.9)', 4326)) <= 25 LIMIT 25";
+
+    const normalizedA = normalizeSql(a);
+    const normalizedB = normalizeSql(b);
+
+    expect(normalizedA).toContain("FORCE INDEX (`idx_county_id`, `idx_property_units_location`)");
+    expect(normalizedA).toContain("ST_DISTANCE_SPHERE");
+    expect(normalizedA).toContain("ST_GEOMFROMTEXT('POINT(? ?)', ?)");
+    expect(normalizedA).toContain("LIMIT ?");
+    expect(normalizedB).toContain("FORCE INDEX (`idx_county_id`, `idx_property_units_location`)");
+    expect(normalizedB).toContain("ST_DISTANCE_SPHERE");
+    expect(normalizedB).toContain("ST_GEOMFROMTEXT('POINT(? ?)', ?)");
+    expect(normalizedB).toContain("LIMIT ?");
+  });
+
 });

package/src/__tests__/sqlBuilders.test.ts

@@ -5,7 +5,6 @@ import { PostQueryBuilder } from '../orm/queries/PostQueryBuilder';
 import { UpdateQueryBuilder } from '../orm/queries/UpdateQueryBuilder';
 import { DeleteQueryBuilder } from '../orm/queries/DeleteQueryBuilder';
 import { buildTestConfig, buildBinaryTestConfig, buildBinaryTestConfigFqn } from './fixtures/c6.fixture';
-import { version } from '../../package.json';
 
 describe('SQL Builders', () => {
   it('builds SELECT with JOIN, WHERE, GROUP BY, HAVING and default LIMIT', () => {
@@ -44,11 +43,11 @@ describe('SQL Builders', () => {
     expect(params).toEqual(['%A%', 10, 1]);
   });
 
-  it('logs SELECT statements with package version', () => {
+  it('logs SELECT aggregate expressions at DEBUG level', () => {
     const config = buildTestConfig();
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
     const qb = new SelectQueryBuilder(config as any, {
-      SELECT: ['actor.first_name'],
+      SELECT: [[C6C.COUNT, 'actor.actor_id', C6C.AS, 'cnt']],
     } as any, false);
 
     qb.build('actor');
@@ -59,7 +58,7 @@ describe('SQL Builders', () => {
     const selectLine = logLines.find((line) => line.includes('[SELECT]'));
 
     expect(selectLine).toBeDefined();
-    expect(selectLine).toContain(`[${version}]`);
+    expect(selectLine).toContain('COUNT(actor.actor_id) AS cnt');
     logSpy.mockRestore();
   });
 

package/src/executors/HttpExecutor.ts

@@ -260,7 +260,7 @@ export class HttpExecutor<
             let cachedRequest: Promise<{ data: ResponseDataType }> | false = false;
 
             if (cacheResults) {
-                cachedRequest = checkCache<ResponseDataType>(requestMethod, tableName, cacheRequestData);
+                cachedRequest = checkCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, logContext);
             }
 
             if (cachedRequest) {
@@ -420,8 +420,13 @@ export class HttpExecutor<
 
                             case POST:
                                 if (dataInsertMultipleRows !== undefined) {
+                                    const convertedRows = dataInsertMultipleRows.map(convert);
+                                    const convertedQuery = convert(query);
                                     return [
-                                        dataInsertMultipleRows.map(convert),
+                                        {
+                                            ...convertedQuery,
+                                            dataInsertMultipleRows: convertedRows,
+                                        },
                                         baseConfig
                                     ];
                                 }

package/src/executors/SqlExecutor.ts

@@ -17,14 +17,75 @@ import type { PoolConnection } from 'mysql2/promise';
 import { Buffer } from 'buffer';
 import { Executor } from "./Executor";
 import {checkCache, setCache} from "../utils/cacheManager";
+import logSql, {
+    SqlAllowListStatus,
+} from "../utils/logSql";
 import { normalizeSingularRequest } from "../utils/normalizeSingularRequest";
 import {sortAndSerializeQueryObject} from "../utils/sortAndSerializeQueryObject";
 import { loadSqlAllowList, normalizeSql } from "../utils/sqlAllowList";
 import { getLogContext, LogLevel, logWithLevel } from "../utils/logLevel";
 
+const SQL_ALLOWLIST_BLOCKED_CODE = "SQL_ALLOWLIST_BLOCKED";
+
+export type SqlAllowListBlockedError = Error & {
+    code: typeof SQL_ALLOWLIST_BLOCKED_CODE;
+    tableName?: string;
+    method?: string;
+    normalizedSql: string;
+    allowListPath: string;
+    sqlAllowList: {
+        sql: string;
+        table: string | null;
+        method: string | null;
+        allowListPath: string;
+        canAdd: boolean;
+    };
+};
+
+const createSqlAllowListBlockedError = (args: {
+    tableName?: string;
+    method?: string;
+    normalizedSql: string;
+    allowListPath: string;
+}): SqlAllowListBlockedError => {
+    const error = new Error(
+        `SQL statement is not permitted by allowlist (${args.allowListPath}).`,
+    ) as SqlAllowListBlockedError;
+
+    error.name = "SqlAllowListBlockedError";
+    error.code = SQL_ALLOWLIST_BLOCKED_CODE;
+    error.tableName = args.tableName;
+    error.method = args.method;
+    error.normalizedSql = args.normalizedSql;
+    error.allowListPath = args.allowListPath;
+    error.sqlAllowList = {
+        sql: args.normalizedSql,
+        table: args.tableName ?? null,
+        method: args.method ?? null,
+        allowListPath: args.allowListPath,
+        canAdd: true,
+    };
+
+    return error;
+};
+
 export class SqlExecutor<
     G extends OrmGenerics
 > extends Executor<G> {
+    private resolveSqlLogMethod(method: iRestMethods, sql: string): string {
+        const token = sql.trim().split(/\s+/, 1)[0]?.toUpperCase();
+        if (token) return token;
+        switch (method) {
+            case C6C.GET:
+                return "SELECT";
+            case C6C.POST:
+                return "INSERT";
+            case C6C.PUT:
+                return "UPDATE";
+            default:
+                return "DELETE";
+        }
+    }
 
     async execute(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>> {
         const { TABLE_NAME } = this.config.restModel;
@@ -487,8 +548,7 @@ export class SqlExecutor<
         const tableName = this.config.restModel.TABLE_NAME;
         const logContext = getLogContext(this.config, this.request);
         const cacheResults = method === C6C.GET
-            && !this.config.sqlAllowListPath
-            && (this.request as { cacheResults?: boolean })?.cacheResults !== false;
+            && (this.request.cacheResults ?? true);
 
         const cacheRequestData = cacheResults
             ? JSON.parse(JSON.stringify(this.request ?? {}))
@@ -503,6 +563,7 @@ export class SqlExecutor<
                 method,
                 tableName,
                 cacheRequestData,
+                logContext
             );
             if (cachedRequest) {
                 return (await cachedRequest).data;
@@ -510,8 +571,15 @@ export class SqlExecutor<
         }
 
         const sqlExecution = this.buildSqlExecutionContext(method, tableName, logContext);
+        const sqlMethod = this.resolveSqlLogMethod(method, sqlExecution.sql);
         const queryPromise = this.withConnection(async (conn) =>
-            this.executeQueryWithLifecycle(conn, method, sqlExecution, logContext),
+            this.executeQueryWithLifecycle(
+                conn,
+                method,
+                sqlExecution,
+                logContext,
+                sqlMethod
+            ),
         );
 
         if (!cacheResults || !cacheRequestData || !requestArgumentsSerialized) {
@@ -640,6 +708,7 @@ export class SqlExecutor<
         method: iRestMethods,
         sqlExecution: iRestSqlExecutionContext,
         logContext: ReturnType<typeof getLogContext>,
+        sqlMethod: string
     ): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>> {
         const useTransaction = method !== C6C.GET;
         let committed = false;
@@ -655,7 +724,27 @@ export class SqlExecutor<
                 await conn.beginTransaction();
             }
 
-            await this.validateSqlAllowList(sqlExecution.sql);
+            let allowListStatus: SqlAllowListStatus = "not verified";
+            try {
+                allowListStatus = await this.validateSqlAllowList(sqlExecution.sql);
+            } catch (error) {
+                logSql({
+                    method: sqlMethod,
+                    sql: sqlExecution.sql,
+                    context: logContext,
+                    cacheStatus: this.request.cacheResults === false ? "ignored" : "miss",
+                    allowListStatus: "denied",
+                });
+                throw error;
+            }
+
+            logSql({
+                method: sqlMethod,
+                sql: sqlExecution.sql,
+                context: logContext,
+                cacheStatus: this.request.cacheResults === false ? "ignored" : "miss",
+                allowListStatus,
+            });
 
             await this.runLifecycleHooks<"beforeExecution">(
                 "beforeExecution",
@@ -729,17 +818,29 @@ export class SqlExecutor<
         }
     }
 
-    private async validateSqlAllowList(sql: string): Promise<void> {
+    private async validateSqlAllowList(sql: string): Promise<SqlAllowListStatus> {
         const allowListPath = this.config.sqlAllowListPath;
         if (!allowListPath) {
-            return;
+            return "not verified";
         }
 
         const allowList = await loadSqlAllowList(allowListPath);
         const normalized = normalizeSql(sql);
         if (!allowList.has(normalized)) {
-            throw new Error(`SQL statement is not permitted by allowlist (${allowListPath}).`);
+            throw createSqlAllowListBlockedError({
+                tableName:
+                    typeof this.config.restModel?.TABLE_NAME === "string"
+                        ? this.config.restModel.TABLE_NAME
+                        : undefined,
+                method:
+                    typeof this.config.requestMethod === "string"
+                        ? this.config.requestMethod
+                        : undefined,
+                normalizedSql: normalized,
+                allowListPath,
+            });
         }
+        return "allowed";
     }
 
 

package/src/orm/queries/DeleteQueryBuilder.ts

@@ -2,8 +2,6 @@ import { OrmGenerics } from "../../types/ormGenerics";
 import { SqlBuilderResult } from "../utils/sqlUtils";
 import { JoinBuilder } from "../builders/JoinBuilder";
 import { SelectQueryBuilder } from "./SelectQueryBuilder";
-import logSql from "../../utils/logSql";
-import {getLogContext} from "../../utils/logLevel";
 
 export class DeleteQueryBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
     protected createSelectBuilder(request: any) {
@@ -27,8 +25,6 @@ export class DeleteQueryBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
             sql += this.buildWhereClause(this.request.WHERE, params);
         }
 
-        logSql("DELETE", sql, getLogContext(this.config, this.request));
-
         return { sql, params };
     }
 }

package/src/orm/queries/PostQueryBuilder.ts

@@ -1,8 +1,6 @@
 import {C6C} from "../../constants/C6Constants";
 import {ConditionBuilder} from "../builders/ConditionBuilder";
 import {OrmGenerics} from "../../types/ormGenerics";
-import logSql from "../../utils/logSql";
-import {getLogContext} from "../../utils/logLevel";
 
 export class PostQueryBuilder<G extends OrmGenerics> extends ConditionBuilder<G>{
 
@@ -61,8 +59,6 @@ export class PostQueryBuilder<G extends OrmGenerics> extends ConditionBuilder<G>
             sql += ` ON DUPLICATE KEY UPDATE ${updateClause}`;
         }
 
-        logSql(verb, sql, getLogContext(this.config, this.request));
-
         return {sql, params};
     }
 }

package/src/orm/queries/SelectQueryBuilder.ts

@@ -1,8 +1,6 @@
 import {OrmGenerics} from "../../types/ormGenerics";
 import {PaginationBuilder} from "../builders/PaginationBuilder";
 import {SqlBuilderResult} from "../utils/sqlUtils";
-import logSql from "../../utils/logSql";
-import {getLogContext} from "../../utils/logLevel";
 
 export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
 
@@ -58,8 +56,6 @@ export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
             sql += ` LIMIT 100`;
         }
 
-        logSql("SELECT", sql, getLogContext(this.config, this.request));
-
         return { sql, params };
     }
 }

package/src/orm/queries/UpdateQueryBuilder.ts

@@ -3,8 +3,6 @@ import {OrmGenerics} from "../../types/ormGenerics";
 import { PaginationBuilder } from '../builders/PaginationBuilder';
 import {SqlBuilderResult} from "../utils/sqlUtils";
 import {SelectQueryBuilder} from "./SelectQueryBuilder";
-import logSql from "../../utils/logSql";
-import {getLogContext} from "../../utils/logLevel";
 
 export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
     protected createSelectBuilder(request: any) {
@@ -56,8 +54,6 @@ export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
             sql += this.buildPaginationClause(args.PAGINATION, params);
         }
 
-        logSql("UPDATE", sql, getLogContext(this.config, this.request));
-
         return { sql, params };
     }
 }

package/src/utils/cacheManager.ts

@@ -1,5 +1,6 @@
 import type {iCacheAPI, iCacheResponse} from "../types/ormInterfaces";
-import {LogLevel, logWithLevel, shouldLog} from "./logLevel";
+import {LogContext, LogLevel, logWithLevel, shouldLog} from "./logLevel";
+import logSql from "./logSql";
 
 // -----------------------------------------------------------------------------
 // Cache Storage
@@ -60,19 +61,26 @@ export function checkCache<ResponseDataType = any>(
     method: string,
     tableName: string | string[],
     requestData: any,
+    logContext: LogContext,
 ): Promise<iCacheResponse<ResponseDataType>> | false {
     const key = makeCacheKey(method, tableName, requestData);
     const cached = apiRequestCache.get(key);
 
-    if (!cached) return false;
+    if (!cached) {
+        console.log('apiRequestCache.size', apiRequestCache.size)
+        return false;
+    }
 
-    if (shouldLog(LogLevel.INFO, undefined)) {
-        console.groupCollapsed(
-            `%c API cache hit for ${method} ${tableName}`,
-            "color:#0c0",
-        );
-        console.log("Request Data:", requestData);
-        console.groupEnd();
+    if (shouldLog(LogLevel.INFO, logContext)) {
+        const sql = cached.response?.data?.sql?.sql ?? "";
+        const sqlMethod = sql.trim().split(/\s+/, 1)[0]?.toUpperCase() || method;
+        logSql({
+            allowListStatus: "not verified",
+            cacheStatus: "hit",
+            context: logContext,
+            method: sqlMethod,
+            sql
+        });
     }
 
     return cached.request;

package/src/utils/logLevel.ts

@@ -135,10 +135,9 @@ export const applyLogLevelDefaults = (
 };
 
 export const getLogContext = (
-    config?: { logLevel?: number | null; verbose?: boolean | null },
-    request?: { debug?: boolean } | null,
-): LogContext | undefined => {
-    if (!config && !request) return undefined;
+    config: { logLevel?: number | null; verbose?: boolean | null },
+    request: { debug?: boolean } | null,
+): LogContext => {
     return {
         logLevel: config?.logLevel ?? undefined,
         verbose: config?.verbose ?? undefined,