@carbonorm/carbonnode 6.0.10 → 6.0.13

package/dist/executors/SqlExecutor.d.ts

@@ -18,5 +18,11 @@ export declare class SqlExecutor<G extends OrmGenerics> extends Executor<G> {
     private extractPrimaryKeyValuesFromData;
     private broadcastWebsocketIfConfigured;
     runQuery(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
+    private getQueryBuilder;
+    private buildSqlExecutionContext;
+    private createResponseFromQueryResult;
+    private createLifecycleHookResponse;
+    private createCacheResponseEnvelope;
+    private executeQueryWithLifecycle;
     private validateSqlAllowList;
 }

package/dist/handlers/ExpressHandler.d.ts

@@ -1,9 +1,8 @@
-import type { Request, Response, NextFunction } from "express";
-import type { Pool } from "mysql2/promise";
-import type { iC6Object, tWebsocketBroadcast } from "../types/ormInterfaces";
-export declare function ExpressHandler({ C6, mysqlPool, sqlAllowListPath, websocketBroadcast, }: {
-    C6: iC6Object;
-    mysqlPool: Pool;
-    sqlAllowListPath?: string;
-    websocketBroadcast?: tWebsocketBroadcast;
-}): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+import type { Request, Response, Router } from "express";
+import { iRest } from "../types/ormInterfaces";
+import { OrmGenerics } from "../types/ormGenerics";
+export declare function restExpressRequest<G extends OrmGenerics>(routerConfig: {
+    router: Pick<Router, "all">;
+    routePath?: string;
+} & Omit<iRest<G['RestShortTableName'], G['RestTableInterface']>, "requestMethod" | "restModel">): void;
+export declare function ExpressHandler<G extends OrmGenerics>(configX: (() => Omit<iRest<G['RestShortTableName'], G['RestTableInterface']>, "requestMethod" | "restModel">) | Omit<iRest<G['RestShortTableName'], G['RestTableInterface']>, "requestMethod" | "restModel">): (req: Request, res: Response) => Promise<void>;

package/dist/index.cjs.js

@@ -536,7 +536,11 @@ var logWithLevel = function (requiredLevel, context, logger) {
 };
 
 function convertForRequestBody (restfulObject, tableName, C6, regexErrorHandler) {
-    if (regexErrorHandler === void 0) { regexErrorHandler = alert; }
+    if (regexErrorHandler === void 0) { regexErrorHandler = function (message) {
+        if (typeof globalThis !== "undefined" && typeof globalThis.alert === "function") {
+            globalThis.alert(message);
+        }
+    }; }
     var payload = {};
     var tableNames = Array.isArray(tableName) ? tableName : [tableName];
     var tableDefinitions = tableNames.map(function (name) {
@@ -559,7 +563,8 @@ function convertForRequestBody (restfulObject, tableName, C6, regexErrorHandler)
                 C6Constants.DELETE,
                 C6Constants.WHERE,
                 C6Constants.JOIN,
-                C6Constants.PAGINATION
+                C6Constants.PAGINATION,
+                "cacheResults",
             ].includes(value)) {
                 var val_1 = restfulObject[value];
                 if (Array.isArray(val_1)) {
@@ -573,6 +578,9 @@ function convertForRequestBody (restfulObject, tableName, C6, regexErrorHandler)
                         return (tslib.__assign(tslib.__assign({}, acc), (_a = {}, _a[key] = val_1[key], _a)));
                     }, {});
                 }
+                else {
+                    payload[value] = val_1;
+                }
                 return "continue";
             }
             if (shortReference in tableDefinition) {
@@ -904,7 +912,7 @@ function checkCache(method, tableName, requestData) {
     var cached = apiRequestCache.get(key);
     if (!cached)
         return false;
-    if (shouldLog(exports.LogLevel.DEBUG, undefined)) {
+    if (shouldLog(exports.LogLevel.INFO, undefined)) {
         console.groupCollapsed("%c API cache hit for ".concat(method, " ").concat(tableName), "color:#0c0");
         console.log("Request Data:", requestData);
         console.groupEnd();
@@ -2131,14 +2139,51 @@ var ConditionBuilder = /** @class */ (function (_super) {
         return typeof mysqlType === 'string' && mysqlType.toLowerCase().includes('json');
     };
     ConditionBuilder.prototype.serializeUpdateValue = function (value, params, contextColumn) {
+        var _a;
+        var _this = this;
         var normalized = value instanceof Map ? Object.fromEntries(value) : value;
         var allowColumnRefs = this.isJsonColumn(contextColumn);
         if (this.isPlainArrayLiteral(normalized, allowColumnRefs)
             || this.isPlainObjectLiteral(normalized, allowColumnRefs)) {
             return this.addParam(params, contextColumn !== null && contextColumn !== void 0 ? contextColumn : '', JSON.stringify(normalized));
         }
-        var _a = this.serializeOperand(normalized, params, contextColumn), sql = _a.sql, isReference = _a.isReference, isExpression = _a.isExpression, isSubSelect = _a.isSubSelect;
+        var sql;
+        var isReference;
+        var isExpression;
+        var isSubSelect;
+        var shouldStringifyObjectFallback = function (candidate) {
+            if (typeof candidate !== 'object'
+                || candidate === null
+                || candidate instanceof Date
+                || (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(candidate))) {
+                return false;
+            }
+            var normalizedCandidate = candidate instanceof Map
+                ? Object.fromEntries(candidate)
+                : candidate;
+            var entries = Object.entries(normalizedCandidate);
+            if (entries.length !== 1) {
+                return true;
+            }
+            var key = entries[0][0];
+            if (_this.isOperator(key) || _this.BOOLEAN_OPERATORS.has(key)) {
+                return false;
+            }
+            return true;
+        };
+        try {
+            (_a = this.serializeOperand(normalized, params, contextColumn), sql = _a.sql, isReference = _a.isReference, isExpression = _a.isExpression, isSubSelect = _a.isSubSelect);
+        }
+        catch (err) {
+            if (shouldStringifyObjectFallback(normalized)) {
+                return this.addParam(params, contextColumn !== null && contextColumn !== void 0 ? contextColumn : '', JSON.stringify(normalized));
+            }
+            throw err;
+        }
         if (!isReference && !isExpression && !isSubSelect && typeof normalized === 'object' && normalized !== null) {
+            if (shouldStringifyObjectFallback(normalized)) {
+                return this.addParam(params, contextColumn !== null && contextColumn !== void 0 ? contextColumn : '', JSON.stringify(normalized));
+            }
             throw new Error('Unsupported operand type in SQL expression.');
         }
         return sql;
@@ -2952,11 +2997,27 @@ function collapseBinds(sql) {
         return "".concat(C$1.DIM, "? \u00D7").concat(count).concat(RESET);
     });
 }
+/**
+ * ( ? ×9 ), ( ? ×9 ), ( ? ×9 )  ->  ( ? ×9 ) ×3
+ */
+function collapseRepeatedValueRows(sql) {
+    var repeatedRowPattern = /(\((?:\x1b\[[0-9;]*m)?\?\s*×\d+(?:\x1b\[[0-9;]*m)?\)|\(\s*(?:\?\s*,\s*)+\?\s*\))(?:\s*,\s*\1){2,}/g;
+    return sql.replace(repeatedRowPattern, function (match, row) {
+        var _a, _b;
+        var rowMatches = match.match(new RegExp(row.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"));
+        var count = (_a = rowMatches === null || rowMatches === void 0 ? void 0 : rowMatches.length) !== null && _a !== void 0 ? _a : 1;
+        var normalizedRow = row.includes("×")
+            ? row
+            : "(".concat(C$1.DIM, "? \u00D7").concat(((_b = row.match(/\?/g)) !== null && _b !== void 0 ? _b : []).length).concat(RESET, ")");
+        return "".concat(normalizedRow, " ").concat(C$1.DIM, "\u00D7").concat(count).concat(RESET);
+    });
+}
 /* ---------- main formatter ---------- */
 function colorSql(sql) {
     var s = sql.trim();
     /* 1️⃣ collapse bind noise */
     s = collapseBinds(s);
+    s = collapseRepeatedValueRows(s);
     /* 2️⃣ table.column coloring (core visual grouping) */
     s = s.replace(/\b(`?\w+`?)\.(\w+)\b/g, function (_, table, column) {
         return "".concat(tableColor(table)).concat(table).concat(RESET, ".") +
@@ -2973,7 +3034,7 @@ function colorSql(sql) {
     return s;
 }
 
-var version = "6.0.10";
+var version = "6.0.13";
 
 var DEFAULT_STEP = 8;
 function parseSemver(version) {
@@ -3160,21 +3221,35 @@ var PostQueryBuilder = /** @class */ (function (_super) {
     };
     PostQueryBuilder.prototype.build = function (table) {
         var _this = this;
+        var _a, _b;
         this.aliasMap = {};
         var verb = C6C.REPLACE in this.request ? C6C.REPLACE : C6C.INSERT;
-        var body = verb in this.request ? this.request[verb] : this.request;
-        var keys = Object.keys(body);
+        var directRows = Array.isArray(this.request)
+            ? this.request
+            : [];
+        var rows = directRows.length > 0
+            ? directRows
+            : Array.isArray(this.request.dataInsertMultipleRows) &&
+                this.request.dataInsertMultipleRows.length > 0
+                ? this.request.dataInsertMultipleRows
+                : [verb in this.request ? this.request[verb] : this.request];
+        var keys = Object.keys((_a = rows[0]) !== null && _a !== void 0 ? _a : {});
         var params = this.useNamedParams ? {} : [];
-        var placeholders = [];
-        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-            var key = keys_1[_i];
-            var value = body[key];
-            var trimmed = this.trimTablePrefix(table, key);
-            var qualified = "".concat(table, ".").concat(trimmed);
-            var placeholder = this.serializeUpdateValue(value, params, qualified);
-            placeholders.push(placeholder);
+        var rowPlaceholders = [];
+        for (var _i = 0, rows_1 = rows; _i < rows_1.length; _i++) {
+            var row = rows_1[_i];
+            var placeholders = [];
+            for (var _c = 0, keys_1 = keys; _c < keys_1.length; _c++) {
+                var key = keys_1[_c];
+                var value = (_b = row[key]) !== null && _b !== void 0 ? _b : null;
+                var trimmed = this.trimTablePrefix(table, key);
+                var qualified = "".concat(table, ".").concat(trimmed);
+                var placeholder = this.serializeUpdateValue(value, params, qualified);
+                placeholders.push(placeholder);
+            }
+            rowPlaceholders.push("(".concat(placeholders.join(', '), ")"));
         }
-        var sql = "".concat(verb, " INTO `").concat(table, "` (\n            ").concat(keys.map(function (k) { return "`".concat(_this.trimTablePrefix(table, k), "`"); }).join(', '), "\n         ) VALUES (\n            ").concat(placeholders.join(', '), "\n        )");
+        var sql = "".concat(verb, " INTO `").concat(table, "` (\n            ").concat(keys.map(function (k) { return "`".concat(_this.trimTablePrefix(table, k), "`"); }).join(', '), "\n         ) VALUES\n            ").concat(rowPlaceholders.join(',\n            '));
         if (C6C.UPDATE in this.request) {
             var updateData = this.request[C6C.UPDATE];
             if (!Array.isArray(updateData)) {
@@ -3494,12 +3569,18 @@ var SqlExecutor = /** @class */ (function (_super) {
     }
     SqlExecutor.prototype.execute = function () {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var TABLE_NAME, method, logContext, _a, rest, result, result, result;
+            var TABLE_NAME, method, logContext, response, _a, rest, getResponse, restRows, result, result, result;
             return tslib.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         TABLE_NAME = this.config.restModel.TABLE_NAME;
                         method = this.config.requestMethod;
+                        return [4 /*yield*/, this.runLifecycleHooks("beforeProcessing", {
+                                config: this.config,
+                                request: this.request,
+                            })];
+                    case 1:
+                        _b.sent();
                         // Normalize singular T-shaped requests into complex ORM shape (GET/PUT/DELETE)
                         try {
                             this.request = normalizeSingularRequest(method, this.request, this.config.restModel, undefined);
@@ -3513,45 +3594,54 @@ var SqlExecutor = /** @class */ (function (_super) {
                         logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE9 Request:", this.request);
                         _a = method;
                         switch (_a) {
-                            case 'GET': return [3 /*break*/, 1];
-                            case 'POST': return [3 /*break*/, 3];
-                            case 'PUT': return [3 /*break*/, 6];
-                            case 'DELETE': return [3 /*break*/, 9];
+                            case 'GET': return [3 /*break*/, 2];
+                            case 'POST': return [3 /*break*/, 4];
+                            case 'PUT': return [3 /*break*/, 7];
+                            case 'DELETE': return [3 /*break*/, 10];
                         }
-                        return [3 /*break*/, 12];
-                    case 1: return [4 /*yield*/, this.runQuery()];
-                    case 2:
+                        return [3 /*break*/, 13];
+                    case 2: return [4 /*yield*/, this.runQuery()];
+                    case 3:
                         rest = _b.sent();
                         if (this.config.reactBootstrap) {
+                            getResponse = rest;
+                            restRows = Array.isArray(getResponse.rest)
+                                ? getResponse.rest
+                                : [getResponse.rest];
                             this.config.reactBootstrap.updateRestfulObjectArrays({
-                                dataOrCallback: rest.rest,
+                                dataOrCallback: restRows,
                                 stateKey: this.config.restModel.TABLE_NAME,
                                 uniqueObjectId: this.config.restModel.PRIMARY_SHORT,
                             });
                         }
-                        return [2 /*return*/, rest];
-                    case 3: return [4 /*yield*/, this.runQuery()];
-                    case 4:
+                        response = rest;
+                        return [3 /*break*/, 14];
+                    case 4: return [4 /*yield*/, this.runQuery()];
+                    case 5:
                         result = _b.sent();
                         return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
-                    case 5:
+                    case 6:
                         _b.sent();
-                        return [2 /*return*/, result];
-                    case 6: return [4 /*yield*/, this.runQuery()];
-                    case 7:
+                        response = result;
+                        return [3 /*break*/, 14];
+                    case 7: return [4 /*yield*/, this.runQuery()];
+                    case 8:
                         result = _b.sent();
                         return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
-                    case 8:
+                    case 9:
                         _b.sent();
-                        return [2 /*return*/, result];
-                    case 9: return [4 /*yield*/, this.runQuery()];
-                    case 10:
+                        response = result;
+                        return [3 /*break*/, 14];
+                    case 10: return [4 /*yield*/, this.runQuery()];
+                    case 11:
                         result = _b.sent();
                         return [4 /*yield*/, this.broadcastWebsocketIfConfigured(result)];
-                    case 11:
+                    case 12:
                         _b.sent();
-                        return [2 /*return*/, result];
-                    case 12: throw new Error("Unsupported request method: ".concat(method));
+                        response = result;
+                        return [3 /*break*/, 14];
+                    case 13: throw new Error("Unsupported request method: ".concat(method));
+                    case 14: return [2 /*return*/, response];
                 }
             });
         });
@@ -3848,65 +3938,182 @@ var SqlExecutor = /** @class */ (function (_super) {
     };
     SqlExecutor.prototype.runQuery = function () {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var TABLE_NAME, method, builder, QueryResult, logContext, formatted, toUnnamed, _a, sql, values;
+            var method, tableName, logContext, cacheResults, cacheRequestData, requestArgumentsSerialized, cachedRequest, sqlExecution, queryPromise, cacheRequest, cacheResponse;
             var _this = this;
-            return tslib.__generator(this, function (_b) {
-                switch (_b.label) {
+            var _a, _b;
+            return tslib.__generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        TABLE_NAME = this.config.restModel.TABLE_NAME;
                         method = this.config.requestMethod;
-                        switch (method) {
-                            case 'GET':
-                                builder = new SelectQueryBuilder(this.config, this.request);
-                                break;
-                            case 'PUT':
-                                builder = new UpdateQueryBuilder(this.config, this.request);
-                                break;
-                            case 'DELETE':
-                                builder = new DeleteQueryBuilder(this.config, this.request);
-                                break;
-                            case 'POST':
-                                builder = new PostQueryBuilder(this.config, this.request);
-                                break;
-                            default:
-                                throw new Error("Unsupported query method: ".concat(method));
-                        }
-                        QueryResult = builder.build(TABLE_NAME);
+                        tableName = this.config.restModel.TABLE_NAME;
                         logContext = getLogContext(this.config, this.request);
-                        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE0 Generated ".concat(method.toUpperCase(), " SQL:"), QueryResult);
-                        formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
-                        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE0 Formatted ".concat(method.toUpperCase(), " SQL:"), formatted);
-                        toUnnamed = namedPlaceholders();
-                        _a = toUnnamed(QueryResult.sql, QueryResult.params), sql = _a[0], values = _a[1];
-                        return [4 /*yield*/, this.validateSqlAllowList(sql)];
+                        cacheResults = method === C6Constants.GET
+                            && !this.config.sqlAllowListPath
+                            && ((_a = this.request) === null || _a === void 0 ? void 0 : _a.cacheResults) !== false;
+                        cacheRequestData = cacheResults
+                            ? JSON.parse(JSON.stringify((_b = this.request) !== null && _b !== void 0 ? _b : {}))
+                            : undefined;
+                        requestArgumentsSerialized = cacheResults
+                            ? sortAndSerializeQueryObject(tableName, cacheRequestData !== null && cacheRequestData !== void 0 ? cacheRequestData : {})
+                            : undefined;
+                        if (!cacheResults) return [3 /*break*/, 2];
+                        cachedRequest = checkCache(method, tableName, cacheRequestData);
+                        if (!cachedRequest) return [3 /*break*/, 2];
+                        return [4 /*yield*/, cachedRequest];
+                    case 1: return [2 /*return*/, (_c.sent()).data];
+                    case 2:
+                        sqlExecution = this.buildSqlExecutionContext(method, tableName, logContext);
+                        queryPromise = this.withConnection(function (conn) { return tslib.__awaiter(_this, void 0, void 0, function () { return tslib.__generator(this, function (_a) {
+                            return [2 /*return*/, this.executeQueryWithLifecycle(conn, method, sqlExecution, logContext)];
+                        }); }); });
+                        if (!(!cacheResults || !cacheRequestData || !requestArgumentsSerialized)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, queryPromise];
+                    case 3: return [2 /*return*/, _c.sent()];
+                    case 4:
+                        cacheRequest = queryPromise.then(function (data) {
+                            return _this.createCacheResponseEnvelope(method, tableName, data);
+                        });
+                        setCache(method, tableName, cacheRequestData, {
+                            requestArgumentsSerialized: requestArgumentsSerialized,
+                            request: cacheRequest,
+                        });
+                        return [4 /*yield*/, cacheRequest];
+                    case 5:
+                        cacheResponse = _c.sent();
+                        setCache(method, tableName, cacheRequestData, {
+                            requestArgumentsSerialized: requestArgumentsSerialized,
+                            request: cacheRequest,
+                            response: cacheResponse,
+                            final: true,
+                        });
+                        return [2 /*return*/, cacheResponse.data];
+                }
+            });
+        });
+    };
+    SqlExecutor.prototype.getQueryBuilder = function (method) {
+        switch (method) {
+            case C6Constants.GET:
+                return new SelectQueryBuilder(this.config, this.request);
+            case C6Constants.PUT:
+                return new UpdateQueryBuilder(this.config, this.request);
+            case C6Constants.DELETE:
+                return new DeleteQueryBuilder(this.config, this.request);
+            case C6Constants.POST:
+                return new PostQueryBuilder(this.config, this.request);
+            default:
+                throw new Error("Unsupported query method: ".concat(method));
+        }
+    };
+    SqlExecutor.prototype.buildSqlExecutionContext = function (method, tableName, logContext) {
+        var builder = this.getQueryBuilder(method);
+        var queryResult = builder.build(tableName);
+        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE0 Generated ".concat(method.toUpperCase(), " SQL:"), queryResult);
+        var formatted = this.formatSQLWithParams(queryResult.sql, queryResult.params);
+        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDE0 Formatted ".concat(method.toUpperCase(), " SQL:"), formatted);
+        var toUnnamed = namedPlaceholders();
+        var _a = toUnnamed(queryResult.sql, queryResult.params), sql = _a[0], values = _a[1];
+        return { sql: sql, values: values };
+    };
+    SqlExecutor.prototype.createResponseFromQueryResult = function (method, result, sqlExecution, logContext) {
+        if (method === C6Constants.GET) {
+            return {
+                rest: result.map(this.serialize),
+                sql: { sql: sqlExecution.sql, values: sqlExecution.values },
+            };
+        }
+        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \u270F\uFE0F Rows affected:", result.affectedRows);
+        return {
+            affected: result.affectedRows,
+            insertId: result.insertId,
+            rest: [],
+            sql: { sql: sqlExecution.sql, values: sqlExecution.values },
+        };
+    };
+    SqlExecutor.prototype.createLifecycleHookResponse = function (response) {
+        var data = Object.assign({ success: true }, response);
+        return { data: data };
+    };
+    SqlExecutor.prototype.createCacheResponseEnvelope = function (method, tableName, data) {
+        return {
+            data: data,
+            config: {
+                method: method.toLowerCase(),
+                url: "/rest/".concat(tableName),
+            },
+        };
+    };
+    SqlExecutor.prototype.executeQueryWithLifecycle = function (conn, method, sqlExecution, logContext) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var useTransaction, committed, result, response, hookResponse, err_1, rollbackErr_1;
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        useTransaction = method !== C6Constants.GET;
+                        committed = false;
+                        _a.label = 1;
                     case 1:
-                        _b.sent();
-                        return [4 /*yield*/, this.withConnection(function (conn) { return tslib.__awaiter(_this, void 0, void 0, function () {
-                                var result;
-                                return tslib.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, conn.query(sql, values)];
-                                        case 1:
-                                            result = (_a.sent())[0];
-                                            if (method === 'GET') {
-                                                return [2 /*return*/, {
-                                                        rest: result.map(this.serialize),
-                                                        sql: { sql: sql, values: values }
-                                                    }];
-                                            }
-                                            else {
-                                                logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \u270F\uFE0F Rows affected:", result.affectedRows);
-                                                return [2 /*return*/, {
-                                                        affected: result.affectedRows,
-                                                        insertId: result.insertId,
-                                                        rest: [], // TODO - remove rest empty array from non-GET responses?
-                                                        sql: { sql: sql, values: values }
-                                                    }];
-                                            }
-                                    }
-                                });
-                            }); })];
-                    case 2: return [2 /*return*/, _b.sent()];
+                        _a.trys.push([1, 11, , 16]);
+                        if (!useTransaction) return [3 /*break*/, 3];
+                        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDFE Beginning transaction");
+                        return [4 /*yield*/, conn.beginTransaction()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [4 /*yield*/, this.validateSqlAllowList(sqlExecution.sql)];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, this.runLifecycleHooks("beforeExecution", {
+                                config: this.config,
+                                request: this.request,
+                                sqlExecution: sqlExecution,
+                            })];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, conn.query(sqlExecution.sql, sqlExecution.values)];
+                    case 6:
+                        result = (_a.sent())[0];
+                        response = this.createResponseFromQueryResult(method, result, sqlExecution, logContext);
+                        hookResponse = this.createLifecycleHookResponse(response);
+                        return [4 /*yield*/, this.runLifecycleHooks("afterExecution", {
+                                config: this.config,
+                                request: this.request,
+                                response: hookResponse,
+                            })];
+                    case 7:
+                        _a.sent();
+                        if (!useTransaction) return [3 /*break*/, 9];
+                        return [4 /*yield*/, conn.commit()];
+                    case 8:
+                        _a.sent();
+                        committed = true;
+                        logWithLevel(exports.LogLevel.DEBUG, logContext, console.log, "[SQL EXECUTOR] \uD83E\uDDFE Transaction committed");
+                        _a.label = 9;
+                    case 9: return [4 /*yield*/, this.runLifecycleHooks("afterCommit", {
+                            config: this.config,
+                            request: this.request,
+                            response: hookResponse,
+                        })];
+                    case 10:
+                        _a.sent();
+                        return [2 /*return*/, response];
+                    case 11:
+                        err_1 = _a.sent();
+                        if (!(useTransaction && !committed)) return [3 /*break*/, 15];
+                        _a.label = 12;
+                    case 12:
+                        _a.trys.push([12, 14, , 15]);
+                        return [4 /*yield*/, conn.rollback()];
+                    case 13:
+                        _a.sent();
+                        logWithLevel(exports.LogLevel.WARN, logContext, console.warn, "[SQL EXECUTOR] \uD83E\uDDFE Transaction rolled back");
+                        return [3 /*break*/, 15];
+                    case 14:
+                        rollbackErr_1 = _a.sent();
+                        logWithLevel(exports.LogLevel.ERROR, logContext, console.error, "[SQL EXECUTOR] Rollback failed", rollbackErr_1);
+                        return [3 /*break*/, 15];
+                    case 15: throw err_1;
+                    case 16: return [2 /*return*/];
                 }
             });
         });
@@ -3941,18 +4148,23 @@ var SqlExecutor$1 = /*#__PURE__*/Object.freeze({
     SqlExecutor: SqlExecutor
 });
 
+function restExpressRequest(routerConfig) {
+    var router = routerConfig.router, _a = routerConfig.routePath, routePath = _a === void 0 ? "/rest/:table{/:primary}" : _a, handlerConfig = tslib.__rest(routerConfig, ["router", "routePath"]);
+    router.all(routePath, ExpressHandler(handlerConfig));
+}
 // TODO - WE MUST make this a generic - optional, but helpful
 // note sure how it would help anyone actually...
-function ExpressHandler(_a) {
+function ExpressHandler(configX) {
     var _this = this;
-    var C6 = _a.C6, mysqlPool = _a.mysqlPool, sqlAllowListPath = _a.sqlAllowListPath, websocketBroadcast = _a.websocketBroadcast;
-    return function (req, res, next) { return tslib.__awaiter(_this, void 0, void 0, function () {
-        var incomingMethod, table, primary, methodOverrideRaw, methodOverride, treatAsGet, method, payload, restModel, primaryKeys_1, primaryShortKeys_1, columnMap_1, resolveShortKey_1, hasPrimaryKeyValues, primaryKeyName, response, err_1;
+    return function (req, res) { return tslib.__awaiter(_this, void 0, void 0, function () {
+        var config, C6, incomingMethod, table, primary, methodOverrideRaw, methodOverride, treatAsGet, method, payload, normalized, restModel, primaryKeys_1, primaryShortKeys_1, columnMap_1, resolveShortKey_1, hasPrimaryKeyValues, primaryKeyName, response, err_1, message;
         var _a, _b, _c, _d, _e, _f, _g;
         return tslib.__generator(this, function (_h) {
             switch (_h.label) {
                 case 0:
                     _h.trys.push([0, 2, , 3]);
+                    config = typeof configX === "function" ? configX() : configX;
+                    C6 = config.C6;
                     incomingMethod = req.method.toUpperCase();
                     table = req.params.table;
                     primary = req.params.primary;
@@ -3961,12 +4173,21 @@ function ExpressHandler(_a) {
                     treatAsGet = incomingMethod === 'POST' && methodOverride === 'GET';
                     method = treatAsGet ? 'GET' : incomingMethod;
                     payload = treatAsGet ? tslib.__assign({}, req.body) : (method === 'GET' ? req.query : req.body);
+                    // Query strings are text; coerce known boolean controls.
+                    if (typeof (payload === null || payload === void 0 ? void 0 : payload.cacheResults) === "string") {
+                        normalized = payload.cacheResults.toLowerCase();
+                        if (normalized === "false")
+                            payload.cacheResults = false;
+                        if (normalized === "true")
+                            payload.cacheResults = true;
+                    }
                     // Remove transport-only METHOD flag so it never leaks into ORM parsing
                     if (treatAsGet && 'METHOD' in payload) {
                         try {
                             delete payload.METHOD;
                         }
-                        catch ( /* noop */_j) { /* noop */ }
+                        catch ( /* noop */_j) { /* noop */
+                        }
                     }
                     // Warn for unsupported overrides but continue normally
                     if (incomingMethod !== 'GET' && methodOverride && methodOverride !== 'GET') {
@@ -4028,22 +4249,16 @@ function ExpressHandler(_a) {
                                 (_g = payload[primaryKeyName]) !== null && _g !== void 0 ? _g : primary;
                         }
                     }
-                    return [4 /*yield*/, restRequest({
-                            C6: C6,
-                            mysqlPool: mysqlPool,
-                            sqlAllowListPath: sqlAllowListPath,
-                            websocketBroadcast: websocketBroadcast,
-                            requestMethod: method,
-                            restModel: C6.TABLES[table]
-                        })(payload)];
+                    return [4 /*yield*/, restRequest(tslib.__assign(tslib.__assign({}, config), { requestMethod: method, restModel: C6.TABLES[table] }))(payload)];
                 case 1:
                     response = _h.sent();
                     res.status(200).json(tslib.__assign({ success: true }, response));
                     return [3 /*break*/, 3];
                 case 2:
                     err_1 = _h.sent();
-                    res.status(500).json({ success: false, error: err_1 });
-                    next(err_1);
+                    message = err_1 instanceof Error ? err_1.message : String(err_1);
+                    logWithLevel(exports.LogLevel.ERROR, undefined, console.error, message);
+                    res.status(500).json({ success: false, error: message });
                     return [3 /*break*/, 3];
                 case 3: return [2 /*return*/];
             }
@@ -4221,6 +4436,7 @@ exports.removeInvalidKeys = removeInvalidKeys;
 exports.removePrefixIfExists = removePrefixIfExists;
 exports.resolveDerivedTable = resolveDerivedTable;
 exports.resolveLogLevel = resolveLogLevel;
+exports.restExpressRequest = restExpressRequest;
 exports.restOrm = restOrm;
 exports.restRequest = restRequest;
 exports.setCache = setCache;