@carbonorm/carbonnode 3.0.12 → 3.0.15

package/dist/index.cjs.js

@@ -4,6 +4,8 @@ var axios = require('axios');
 var Qs = require('qs');
 var tslib = require('tslib');
 var reactToastify = require('react-toastify');
+var namedPlaceholders = require('named-placeholders');
+var buffer = require('buffer');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 var C6Constants = {
@@ -69,6 +71,7 @@ var C6Constants = {
     LOCALTIMESTAMP: 'LOCALTIMESTAMP',
     MAKEDATE: 'MAKEDATE',
     MAKETIME: 'MAKETIME',
+    MATCH_AGAINST: 'MATCH_AGAINST',
     MONTHNAME: 'MONTHNAME',
     MICROSECOND: 'MICROSECOND',
     MINUTE: 'MINUTE',
@@ -443,203 +446,400 @@ var Executor = /** @class */ (function () {
 var SqlBuilder = /** @class */ (function (_super) {
     tslib.__extends(SqlBuilder, _super);
     function SqlBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        /** Flag to determine if named placeholders should be used */
+        _this.useNamedParams = false;
+        return _this;
     }
-    /** Generate nested WHERE/JOIN conditions with parameter binding */
+    SqlBuilder.prototype.convertHexIfBinary = function (col, val) {
+        var _a;
+        var columnDef = (_a = this.config.C6.TABLES[this.config.restModel.TABLE_NAME].TYPE_VALIDATION) === null || _a === void 0 ? void 0 : _a[col];
+        if (typeof val === 'string' &&
+            /^[0-9a-fA-F]{32}$/.test(val) &&
+            typeof columnDef === 'object' &&
+            columnDef.MYSQL_TYPE.toUpperCase().includes('BINARY')) {
+            return Buffer.from(val, 'hex');
+        }
+        return val;
+    };
+    /** Generate nested WHERE/ON conditions with parameter binding (supports AND/OR/NOT) */
     SqlBuilder.prototype.buildBooleanJoinedConditions = function (set, andMode, params) {
+        var _this = this;
         if (andMode === void 0) { andMode = true; }
         if (params === void 0) { params = []; }
         var booleanOperator = andMode ? 'AND' : 'OR';
-        var OPERATORS = ['=', '!=', '<', '<=', '>', '>=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'IS', 'IS NOT'];
-        var isAggregateArray = function (value) {
-            return Array.isArray(value) && typeof value[0] === 'string' && OPERATORS.includes(value[0]);
-        };
+        var OPERATORS = [
+            '=', '!=', '<', '<=', '>', '>=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'IS', 'IS NOT',
+            'BETWEEN', 'NOT BETWEEN', C6Constants.MATCH_AGAINST
+        ];
         var isNumericKeyed = function (obj) {
             return Array.isArray(obj) && Object.keys(obj).every(function (k) { return /^\d+$/.test(k); });
         };
+        // Helper to add a single condition with proper parameter binding
         var addCondition = function (column, op, value) {
             var clause;
-            /*if (Buffer.isBuffer(value)) { // TODO - I want this as a parameterized option, for now default to faster
-                params.push(value.toString('hex')); // Or use UNHEX(?) in SQL
-                clause = `(${column} = UNHEX(?))`;
-            } else {*/
-            params.push(value);
-            clause = "( ".concat(column, " ").concat(op, " ? )");
-            //}
-            isVerbose() && console.log("[WHERE] \u2795 ".concat(clause, " ->"), value);
+            // If using named parameters, generate a unique key; otherwise use positional placeholder
+            var addParam = function (val) {
+                if (Array.isArray(params)) {
+                    // Positional (unnamed) parameter
+                    params.push(_this.convertHexIfBinary(column, val));
+                    return '?';
+                }
+                else {
+                    // Named parameter mode
+                    var key = "param".concat(Object.keys(params).length);
+                    params[key] = _this.convertHexIfBinary(column, val);
+                    return ":".concat(key);
+                }
+            };
+            if ((op === 'IN' || op === 'NOT IN') && Array.isArray(value)) {
+                if (value.length === 0) {
+                    // Edge case: empty IN list - use a condition that's always false
+                    clause = "( ".concat(column, " ").concat(op, " (NULL) )");
+                    isVerbose() && console.warn("[WHERE] Empty list for ".concat(op, " on ").concat(column));
+                }
+                else {
+                    var placeholders = value.map(function (val) { return addParam(val); }).join(', ');
+                    clause = "( ".concat(column, " ").concat(op, " (").concat(placeholders, ") )");
+                }
+            }
+            else if ((op === 'BETWEEN' || op === 'NOT BETWEEN') && Array.isArray(value) && value.length === 2) {
+                // BETWEEN expects exactly two values [min, max]
+                var minVal = value[0], maxVal = value[1];
+                var ph1 = addParam(minVal);
+                var ph2 = addParam(maxVal);
+                clause = "( ".concat(column, " ").concat(op, " ").concat(ph1, " AND ").concat(ph2, " )");
+            }
+            else {
+                // Default case for single-value operators (including IS, IS NOT, =, etc.)
+                // Note: If value is null and op is 'IS' or 'IS NOT', the placeholder will safely bind null.
+                var ph = addParam(value);
+                clause = "( ".concat(column, " ").concat(op, " ").concat(ph, " )");
+            }
+            isVerbose() && console.log("[WHERE] \u2795 ".concat(clause));
             return clause;
         };
         var sql;
         if (isNumericKeyed(set)) {
-            isVerbose() && console.log("[WHERE] Numeric keyed condition:", set);
-            switch (set.length) {
-                case 2:
-                    sql = addCondition(set[0], '=', set[1]);
-                    break;
-                case 3:
-                    if (!OPERATORS.includes(set[1]))
-                        throw new Error("Invalid operator: ".concat(set[1]));
-                    sql = addCondition(set[0], set[1], set[2]);
-                    break;
-                default:
-                    throw new Error("Invalid array condition: ".concat(JSON.stringify(set)));
+            // Array of conditions, use opposite boolean mode for combining (AND/OR swap)
+            isVerbose() && console.log("[WHERE] Grouping conditions (array) in ".concat(andMode ? 'AND' : 'OR', " mode:"), set);
+            if (set.length === 0) {
+                sql = ''; // no conditions
+            }
+            else if (set.length === 1) {
+                // Single element array, just build it normally (no boolean operator needed)
+                sql = this.buildBooleanJoinedConditions(set[0], true, params);
+            }
+            else {
+                // Multiple conditions: join them with the opposite of current mode
+                var subClauses = set.map(function (item) { return _this.buildBooleanJoinedConditions(item, true, params); });
+                var op = andMode ? 'OR' : 'AND';
+                sql = subClauses.map(function (sc) { return "(".concat(sc, ")"); }).join(" ".concat(op, " "));
             }
         }
-        else {
+        else if (typeof set === 'object') {
             var parts = [];
             for (var _i = 0, _a = Object.entries(set); _i < _a.length; _i++) {
                 var _b = _a[_i], key = _b[0], value = _b[1];
                 if (/^\d+$/.test(key)) {
+                    // Numeric object keys (should not happen because numeric arrays handled above)
                     parts.push(this.buildBooleanJoinedConditions(value, !andMode, params));
                 }
-                else if (!Array.isArray(value) || isAggregateArray(value)) {
-                    parts.push(addCondition(key, '=', value));
+                else if (key.toUpperCase() === 'NOT') {
+                    // NOT operator: negate the inner condition(s)
+                    var negated = this.buildBooleanJoinedConditions(value, true, params);
+                    parts.push("NOT (".concat(negated, ")"));
+                    isVerbose() && console.log("[WHERE] NOT block: (".concat(negated, ")"));
+                }
+                else if (!Array.isArray(value)) {
+                    if (typeof value === 'object' && value !== null && Object.keys(value).length === 1) {
+                        var _c = Object.entries(value)[0], op = _c[0], val = _c[1];
+                        if (OPERATORS.includes(op.toUpperCase())) {
+                            if (value !== null &&
+                                C6Constants.MATCH_AGAINST in value &&
+                                Array.isArray(value[C6Constants.MATCH_AGAINST])) {
+                                var _d = value[C6Constants.MATCH_AGAINST], search = _d[0], mode = _d[1];
+                                var paramName = "param".concat(Object.keys(params).length);
+                                params[paramName] = search;
+                                var againstClause = void 0;
+                                switch (mode === null || mode === void 0 ? void 0 : mode.toUpperCase()) {
+                                    case 'BOOLEAN':
+                                        againstClause = "AGAINST(:".concat(paramName, " IN BOOLEAN MODE)");
+                                        break;
+                                    case 'WITH QUERY EXPANSION':
+                                        againstClause = "AGAINST(:".concat(paramName, " WITH QUERY EXPANSION)");
+                                        break;
+                                    case 'NATURAL':
+                                    case undefined:
+                                    case null:
+                                        againstClause = "AGAINST(:".concat(paramName, ")"); // default natural language mode
+                                        break;
+                                    default:
+                                        throw new Error("Unsupported MATCH_AGAINST mode: ".concat(mode));
+                                }
+                                parts.push("(MATCH(".concat(key, ") ").concat(againstClause, ")"));
+                                continue;
+                            }
+                            parts.push(addCondition(key, op.toUpperCase(), val));
+                        }
+                        else {
+                            throw new Error("Unsupported operator '".concat(op, "' for key '").concat(key, "'"));
+                        }
+                    }
+                    else {
+                        // Fallback: treat as simple equality
+                        parts.push(addCondition(key, '=', value));
+                    }
                 }
                 else if (value.length === 2 && OPERATORS.includes(value[0])) {
+                    // Two-element array, first is an operator (like ['>', 5])
                     parts.push(addCondition(key, value[0], value[1]));
                 }
+                else if (value.length === 3 && OPERATORS.includes(value[0])) {
+                    // Three-element array, e.g. ['BETWEEN', min, max]
+                    parts.push(addCondition(key, value[0], value.slice(1)));
+                }
                 else {
                     throw new Error("Invalid condition for ".concat(key, ": ").concat(JSON.stringify(value)));
                 }
             }
-            sql = parts.join(" ".concat(booleanOperator, " "));
+            sql = parts.length ? parts.join(" ".concat(booleanOperator, " ")) : '';
+        }
+        else {
+            // Primitive type (should not happen normally), treat it as a boolean expression string
+            sql = String(set);
         }
-        isVerbose() && console.log("[WHERE] Final: (".concat(sql, ")"));
-        return "(".concat(sql, ")");
+        // Wrap the final combined condition in parentheses to maintain correct precedence
+        return sql ? "(".concat(sql, ")") : '';
     };
-    /** Translate array or function calls into SQL expressions */
+    /** Translate array or function call definitions into SQL expressions (supports nested calls) */
     SqlBuilder.prototype.buildAggregateField = function (field) {
-        if (typeof field === 'string')
+        var _this = this;
+        if (typeof field === 'string') {
             return field;
-        if (!Array.isArray(field))
-            throw new Error('Invalid SELECT entry');
+        }
+        if (!Array.isArray(field) || field.length === 0) {
+            throw new Error('Invalid SELECT field entry');
+        }
+        // e.g. field = [ 'ROUND', [ 'SQRT', 'age' ], 2, 'AS', 'roundedRootAge' ]
         var fn = field[0], args = field.slice(1);
         var alias;
-        if (args.length >= 2 && args[args.length - 2] === 'AS') {
-            alias = String(args.pop());
-            args.pop();
+        // Handle alias if present in array (e.g. ... 'AS', 'aliasName')
+        if (args.length >= 2 && String(args[args.length - 2]).toUpperCase() === 'AS') {
+            alias = String(args.pop()); // last element is alias name
+            args.pop(); // remove the 'AS'
         }
         var F = String(fn).toUpperCase();
-        var p = args.join(', ');
-        isVerbose() && console.log("[SELECT] ".concat(F, "(").concat(p, ")").concat(alias ? " AS ".concat(alias) : ''));
+        // Map each argument to SQL string, handling nested function arrays recursively
+        var argList = args.map(function (arg) {
+            if (Array.isArray(arg)) {
+                return _this.buildAggregateField(arg);
+            }
+            else {
+                return arg;
+            }
+        }).join(', ');
+        var expr;
         switch (F) {
             case 'DATE_ADD':
-                return "DATE_ADD(".concat(args[0], ", ").concat(args[1], ")").concat(alias ? " AS ".concat(alias) : '');
             case 'DATE_SUB':
-                return "DATE_SUB(".concat(args[0], ", ").concat(args[1], ")").concat(alias ? " AS ".concat(alias) : '');
+                // Functions with comma-separated interval, assume args like [ date, interval_expression ]
+                expr = "".concat(F, "(").concat(argList, ")");
+                break;
             case 'YEAR':
-                return "YEAR(".concat(args[0], ")").concat(alias ? " AS ".concat(alias) : '');
             case 'MONTH':
-                return "MONTH(".concat(args[0], ")").concat(alias ? " AS ".concat(alias) : '');
             case 'DAY':
-                return "DAY(".concat(args[0], ")").concat(alias ? " AS ".concat(alias) : '');
             case 'ROUND':
             case 'CEIL':
             case 'FLOOR':
             case 'ABS':
             case 'SQRT':
-                return "".concat(F, "(").concat(p, ")").concat(alias ? " AS ".concat(alias) : '');
+            case 'UPPER':
+            case 'LOWER':
+            case 'COALESCE':
+            case 'CONCAT':
+            case 'IFNULL':
+            case 'IF':
+            case 'COUNT':
+            case 'SUM':
+            case 'MIN':
+            case 'MAX':
+            case 'AVG':
+                // Common SQL functions – just format as F(arg1, arg2, ...)
+                expr = "".concat(F, "(").concat(argList, ")");
+                break;
             case 'ST_DISTANCE':
-                return "ST_Distance(".concat(p, ")").concat(alias ? " AS ".concat(alias) : '');
+                expr = "ST_Distance(".concat(argList, ")");
+                break;
             default:
-                if (/^[A-Z_]+$/.test(F))
-                    return "".concat(F, "(").concat(p, ")").concat(alias ? " AS ".concat(alias) : '');
-                throw new Error("Unsupported function: ".concat(F));
+                if (/^[A-Z_]+$/.test(F)) {
+                    // Allow any other SQL function by name (assuming it's a valid function)
+                    expr = "".concat(F, "(").concat(argList, ")");
+                }
+                else {
+                    throw new Error("Unsupported function: ".concat(F));
+                }
+        }
+        if (alias) {
+            expr += " AS ".concat(alias);
+        }
+        isVerbose() && console.log("[SELECT] ".concat(expr));
+        return expr;
+    };
+    SqlBuilder.prototype.buildJoinClauses = function (joinArgs, params) {
+        var sql = '';
+        for (var joinType in joinArgs) {
+            var jk = joinType.replace('_', ' ').toUpperCase();
+            for (var joinTable in joinArgs[joinType]) {
+                var onConditions = joinArgs[joinType][joinTable];
+                var onClause = this.buildBooleanJoinedConditions(onConditions, true, params);
+                sql += " ".concat(jk, " JOIN `").concat(joinTable, "` ON ").concat(onClause);
+                isVerbose() && console.log("[JOIN] ".concat(jk, " JOIN ").concat(joinTable, " ON ").concat(onClause));
+            }
         }
+        return sql;
+    };
+    SqlBuilder.prototype.buildPaginationClause = function (pagination, _params) {
+        var _a;
+        var sql = '';
+        if (pagination === null || pagination === void 0 ? void 0 : pagination[C6Constants.ORDER]) {
+            var orderParts = Object.entries(pagination[C6Constants.ORDER])
+                .map(function (_a) {
+                var col = _a[0], dir = _a[1];
+                return "".concat(col, " ").concat(String(dir).toUpperCase());
+            });
+            sql += " ORDER BY ".concat(orderParts.join(', '));
+            isVerbose() && console.log("[ORDER BY] ".concat(orderParts));
+        }
+        if ((pagination === null || pagination === void 0 ? void 0 : pagination[C6Constants.LIMIT]) != null) {
+            var lim = parseInt(pagination[C6Constants.LIMIT], 10);
+            var page = parseInt((_a = pagination[C6Constants.PAGE]) !== null && _a !== void 0 ? _a : 1, 10);
+            var offset = (page - 1) * lim;
+            sql += " LIMIT ".concat(offset, ", ").concat(lim);
+            isVerbose() && console.log("[LIMIT] ".concat(offset, ", ").concat(lim));
+        }
+        return sql;
+    };
+    SqlBuilder.prototype.buildWhereClause = function (whereArg, params) {
+        var whereClause = this.buildBooleanJoinedConditions(whereArg, true, params);
+        if (whereClause) {
+            var trimmed = whereClause.replace(/^\((.*)\)$/, '$1');
+            isVerbose() && console.log("[WHERE] ".concat(trimmed));
+            return " WHERE ".concat(trimmed);
+        }
+        return '';
     };
-    /** Compose a parameterized SELECT query with optional JOIN/WHERE/GROUP/HAVING/PAGINATION */
     SqlBuilder.prototype.buildSelectQuery = function (table, primary, args, isSubSelect) {
         var _this = this;
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         if (isSubSelect === void 0) { isSubSelect = false; }
         var model = this.config.C6.TABLES[table];
-        var params = [];
-        // SELECT
+        var params = this.useNamedParams ? {} : [];
         var selectList = (_a = args === null || args === void 0 ? void 0 : args[C6Constants.SELECT]) !== null && _a !== void 0 ? _a : ['*'];
         var selectFields = Array.isArray(selectList)
             ? selectList.map(function (f) { return _this.buildAggregateField(f); }).join(', ')
-            : '*';
+            : String(selectList);
         var sql = "SELECT ".concat(selectFields, " FROM ").concat(table);
-        isVerbose() && console.log("[SELECT]", selectFields);
-        // JOIN
         if (args === null || args === void 0 ? void 0 : args[C6Constants.JOIN]) {
-            for (var jt in args[C6Constants.JOIN]) {
-                var jk = jt.replace('_', ' ').toUpperCase();
-                for (var jn in args[C6Constants.JOIN][jt]) {
-                    var on = this.buildBooleanJoinedConditions(args[C6Constants.JOIN][jt][jn], true, params);
-                    sql += " ".concat(jk, " JOIN `").concat(jn, "` ON ").concat(on);
-                    isVerbose() && console.log("[JOIN]", jk, jn, on);
-                }
-            }
+            sql += this.buildJoinClauses(args[C6Constants.JOIN], params);
         }
-        // WHERE
         if (args === null || args === void 0 ? void 0 : args[C6Constants.WHERE]) {
-            var wc = this.buildBooleanJoinedConditions(args[C6Constants.WHERE], true, params);
-            // Trim leading and trailing parentheses if they fully wrap the condition
-            while (wc.startsWith('(') && wc.endsWith(')')) {
-                wc = wc.slice(1, -1).trim();
-            }
-            sql += " WHERE ".concat(wc);
+            sql += this.buildWhereClause(args[C6Constants.WHERE], params);
         }
-        // GROUP BY
         if (args === null || args === void 0 ? void 0 : args[C6Constants.GROUP_BY]) {
             var gb = Array.isArray(args[C6Constants.GROUP_BY])
                 ? args[C6Constants.GROUP_BY].join(', ')
                 : args[C6Constants.GROUP_BY];
             sql += " GROUP BY ".concat(gb);
-            isVerbose() && console.log("[GROUP BY]", gb);
+            isVerbose() && console.log("[GROUP BY] ".concat(gb));
         }
-        // HAVING
         if (args === null || args === void 0 ? void 0 : args[C6Constants.HAVING]) {
-            var hc = this.buildBooleanJoinedConditions(args[C6Constants.HAVING], true, params);
-            sql += " HAVING ".concat(hc);
+            var havingClause = this.buildBooleanJoinedConditions(args[C6Constants.HAVING], true, params);
+            if (havingClause) {
+                sql += " HAVING ".concat(havingClause);
+            }
         }
-        // PAGINATION
         if (args === null || args === void 0 ? void 0 : args[C6Constants.PAGINATION]) {
-            var p = args[C6Constants.PAGINATION];
-            if (p[C6Constants.ORDER]) {
-                var ord = Object.entries(p[C6Constants.ORDER]).map(function (_a) {
-                    var c = _a[0], d = _a[1];
-                    return "".concat(c, " ").concat(String(d).toUpperCase());
-                });
-                sql += " ORDER BY ".concat(ord.join(', '));
-                isVerbose() && console.log("[ORDER BY]", ord);
-            }
-            if (p[C6Constants.LIMIT] != null) {
-                var lim = parseInt(p[C6Constants.LIMIT], 10);
-                var pg = parseInt((_b = p[C6Constants.PAGE]) !== null && _b !== void 0 ? _b : 1, 10);
-                var off = (pg - 1) * lim;
-                sql += " LIMIT ".concat(off, ", ").concat(lim);
-                isVerbose() && console.log("[LIMIT]", off, lim);
-            }
+            sql += this.buildPaginationClause(args[C6Constants.PAGINATION], params);
         }
-        // Fallback ORDER/LIMIT
         else if (!isSubSelect) {
-            var ok = void 0;
-            if (primary)
-                ok = primary;
-            else if ((_c = model === null || model === void 0 ? void 0 : model.PRIMARY_SHORT) === null || _c === void 0 ? void 0 : _c[0])
-                ok = model.PRIMARY_SHORT[0];
-            else
-                for (var _i = 0, _e = ['created_at', 'updated_at']; _i < _e.length; _i++) {
-                    var ts = _e[_i];
-                    if ((_d = model === null || model === void 0 ? void 0 : model.COLUMNS) === null || _d === void 0 ? void 0 : _d["".concat(table, ".").concat(ts)]) {
-                        ok = ts;
+            var orderKey = primary || ((_b = model === null || model === void 0 ? void 0 : model.PRIMARY_SHORT) === null || _b === void 0 ? void 0 : _b[0]);
+            if (!orderKey) {
+                for (var _i = 0, _d = ['created_at', 'updated_at']; _i < _d.length; _i++) {
+                    var ts = _d[_i];
+                    if ((_c = model === null || model === void 0 ? void 0 : model.COLUMNS) === null || _c === void 0 ? void 0 : _c["".concat(table, ".").concat(ts)]) {
+                        orderKey = ts;
                         break;
                     }
                 }
-            if (ok) {
+            }
+            if (orderKey) {
                 var dir = primary ? 'ASC' : 'DESC';
-                var lim = primary ? 1 : 100;
-                sql += " ORDER BY ".concat(ok, " ").concat(dir, " LIMIT ").concat(lim);
-                isVerbose() && console.log("[ORDER]", ok, dir, lim);
+                sql += " ORDER BY ".concat(orderKey, " ").concat(dir, " LIMIT ").concat(primary ? 1 : 100);
+                isVerbose() && console.log("[DEFAULT ORDER] ".concat(orderKey, " ").concat(dir));
             }
             else {
                 sql += " LIMIT 100";
-                isVerbose() && console.warn("[ORDER] fallback LIMIT 100");
+                isVerbose() && console.warn("[DEFAULT LIMIT] 100 (no order key found)");
+            }
+        }
+        isVerbose() && console.log("[SQL SELECT]", sql, params);
+        return { sql: sql, params: params };
+    };
+    SqlBuilder.prototype.buildUpdateQuery = function (table, data, args) {
+        if (args === void 0) { args = {}; }
+        var params = this.useNamedParams ? {} : [];
+        var sql = "UPDATE ".concat(table);
+        if (args[C6Constants.JOIN]) {
+            sql += this.buildJoinClauses(args[C6Constants.JOIN], params);
+        }
+        var setClauses = [];
+        for (var _i = 0, _a = Object.entries(data); _i < _a.length; _i++) {
+            var _b = _a[_i], col = _b[0], val = _b[1];
+            if (Array.isArray(val)) {
+                var expr = this.buildAggregateField(val);
+                setClauses.push("`".concat(col, "` = ").concat(expr));
+            }
+            else {
+                var key = "param".concat(Array.isArray(params) ? params.length : Object.keys(params).length);
+                if (Array.isArray(params)) {
+                    params.push(val);
+                    setClauses.push("`".concat(col, "` = ?"));
+                }
+                else {
+                    params[key] = val;
+                    setClauses.push("`".concat(col, "` = :").concat(key));
+                }
             }
         }
-        isVerbose() && console.log("[SQL]", sql, params);
+        sql += " SET ".concat(setClauses.join(', '));
+        isVerbose() && console.log("[SET] ".concat(setClauses));
+        if (args[C6Constants.WHERE]) {
+            sql += this.buildWhereClause(args[C6Constants.WHERE], params);
+        }
+        if (args[C6Constants.PAGINATION]) {
+            sql += this.buildPaginationClause(args[C6Constants.PAGINATION], params);
+        }
+        isVerbose() && console.log("[SQL UPDATE]", sql, params);
+        return { sql: sql, params: params };
+    };
+    /** Compose a DELETE query with optional JOIN and WHERE clauses */
+    SqlBuilder.prototype.buildDeleteQuery = function (table, args) {
+        if (args === void 0) { args = {}; }
+        var params = this.useNamedParams ? {} : [];
+        var sql = args[C6Constants.JOIN]
+            ? "DELETE ".concat(table, " FROM ").concat(table)
+            : "DELETE FROM ".concat(table);
+        if (args[C6Constants.JOIN]) {
+            sql += this.buildJoinClauses(args[C6Constants.JOIN], params);
+        }
+        if (args[C6Constants.WHERE]) {
+            sql += this.buildWhereClause(args[C6Constants.WHERE], params);
+        }
+        if (args[C6Constants.PAGINATION]) {
+            sql += this.buildPaginationClause(args[C6Constants.PAGINATION], params);
+        }
+        isVerbose() && console.log("[SQL DELETE]", sql, params);
         return { sql: sql, params: params };
     };
     return SqlBuilder;
@@ -1366,7 +1566,12 @@ var HttpExecutor$1 = /*#__PURE__*/Object.freeze({
 var SqlExecutor = /** @class */ (function (_super) {
     tslib.__extends(SqlExecutor, _super);
     function SqlExecutor() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.serialize = function (row) { return Object.fromEntries(Object.entries(row).map(function (_a) {
+            var k = _a[0], v = _a[1];
+            return [k, buffer.Buffer.isBuffer(v) ? v.toString('hex').toUpperCase() : v];
+        })); };
+        return _this;
     }
     SqlExecutor.prototype.execute = function () {
         return tslib.__awaiter(this, void 0, void 0, function () {
@@ -1390,7 +1595,7 @@ var SqlExecutor = /** @class */ (function (_super) {
                     case 2:
                         rest = _b.sent();
                         console.log("[SQL EXECUTOR] \u2705 GET result:", rest);
-                        return [2 /*return*/, { rest: rest }];
+                        return [2 /*return*/, rest];
                     case 3: return [4 /*yield*/, this.insert(TABLE_NAME, this.request)];
                     case 4:
                         result = _b.sent();
@@ -1401,11 +1606,7 @@ var SqlExecutor = /** @class */ (function (_super) {
                     case 6:
                         result = _b.sent();
                         console.log("[SQL EXECUTOR] \u2705 PUT result:", result);
-                        updated = {
-                            rest: result,
-                            updated: true,
-                            rowCount: result.affectedRows
-                        };
+                        updated = tslib.__assign(tslib.__assign({}, result), { updated: true, rowCount: result.rest.affectedRows });
                         return [2 /*return*/, updated];
                     case 7: return [4 /*yield*/, this.delete(TABLE_NAME, [], this.request)];
                     case 8:
@@ -1414,7 +1615,7 @@ var SqlExecutor = /** @class */ (function (_super) {
                         deleted = {
                             rest: result,
                             deleted: true,
-                            rowCount: result.affectedRows
+                            rowCount: result.rest.affectedRows
                         };
                         return [2 /*return*/, deleted];
                     case 9: throw new Error("Unsupported request method: ".concat(method));
@@ -1449,28 +1650,36 @@ var SqlExecutor = /** @class */ (function (_super) {
     };
     SqlExecutor.prototype.select = function (table, primary, args) {
         return tslib.__awaiter(this, void 0, void 0, function () {
-            var sql, formatted;
+            var QueryResult, formatted, toUnnamed, _a, sql, values;
             var _this = this;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
+            return tslib.__generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
-                        sql = this.buildSelectQuery(table, primary, args);
-                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated SELECT SQL:", sql);
-                        formatted = this.formatSQLWithParams(sql.sql, sql.params);
+                        QueryResult = this.buildSelectQuery(table, primary, args);
+                        console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated SELECT SQL:", QueryResult);
+                        formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
                         console.log("[SQL EXECUTOR] \uD83E\uDDE0 Formatted SELECT SQL:", formatted);
+                        toUnnamed = namedPlaceholders();
+                        _a = toUnnamed(QueryResult.sql, QueryResult.params), sql = _a[0], values = _a[1];
                         return [4 /*yield*/, this.withConnection(function (conn) { return tslib.__awaiter(_this, void 0, void 0, function () {
                                 var rows;
                                 return tslib.__generator(this, function (_a) {
                                     switch (_a.label) {
-                                        case 0: return [4 /*yield*/, conn.query(sql.sql, sql.params)];
+                                        case 0: return [4 /*yield*/, conn.query(sql, values)];
                                         case 1:
                                             rows = (_a.sent())[0];
                                             console.log("[SQL EXECUTOR] \uD83D\uDCE6 Rows fetched:", rows);
-                                            return [2 /*return*/, rows];
+                                            return [2 /*return*/, {
+                                                    rest: rows.map(this.serialize),
+                                                    sql: {
+                                                        sql: sql,
+                                                        values: values
+                                                    }
+                                                }];
                                     }
                                 });
                             }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
+                    case 1: return [2 /*return*/, _b.sent()];
                 }
             });
         });
@@ -1485,7 +1694,7 @@ var SqlExecutor = /** @class */ (function (_super) {
                         keys = Object.keys(data);
                         values = keys.map(function (k) { return data[k]; });
                         placeholders = keys.map(function () { return '?'; }).join(', ');
-                        sql = "INSERT INTO `".concat(table, "` (").concat(keys.join(', '), ") VALUES (").concat(placeholders, ")");
+                        sql = "INSERT INTO `".concat(table, "` (").concat(keys.join(', '), ")\n                     VALUES (").concat(placeholders, ")");
                         console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated INSERT SQL:", sql);
                         console.log("[SQL EXECUTOR] \uD83D\uDD22 Values:", values);
                         return [4 /*yield*/, this.withConnection(function (conn) { return tslib.__awaiter(_this, void 0, void 0, function () {
@@ -1495,7 +1704,13 @@ var SqlExecutor = /** @class */ (function (_super) {
                                         case 0: return [4 /*yield*/, conn.execute(sql, values)];
                                         case 1:
                                             result = (_a.sent())[0];
-                                            return [2 /*return*/, result];
+                                            return [2 /*return*/, {
+                                                    rest: result,
+                                                    sql: {
+                                                        sql: sql,
+                                                        placeholders: placeholders
+                                                    }
+                                                }];
                                     }
                                 });
                             }); })];
@@ -1516,7 +1731,7 @@ var SqlExecutor = /** @class */ (function (_super) {
                         keys = Object.keys(data);
                         values = keys.map(function (k) { return data[k]; });
                         updates = keys.map(function (k) { return "`".concat(k, "` = ?"); }).join(', ');
-                        sql = "UPDATE `".concat(table, "` SET ").concat(updates, " WHERE `").concat(primary[0], "` = ?");
+                        sql = "UPDATE `".concat(table, "`\n                     SET ").concat(updates, "\n                     WHERE `").concat(primary[0], "` = ?");
                         values.push(data[primary[0]]);
                         console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated UPDATE SQL:", sql);
                         console.log("[SQL EXECUTOR] \uD83D\uDD22 Values:", values);
@@ -1527,7 +1742,13 @@ var SqlExecutor = /** @class */ (function (_super) {
                                         case 0: return [4 /*yield*/, conn.execute(sql, values)];
                                         case 1:
                                             result = (_a.sent())[0];
-                                            return [2 /*return*/, result];
+                                            return [2 /*return*/, {
+                                                    rest: result,
+                                                    sql: {
+                                                        sql: sql,
+                                                        values: values
+                                                    }
+                                                }];
                                     }
                                 });
                             }); })];
@@ -1546,7 +1767,7 @@ var SqlExecutor = /** @class */ (function (_super) {
                         key = primary === null || primary === void 0 ? void 0 : primary[0];
                         if (!key || !(args === null || args === void 0 ? void 0 : args[key]))
                             throw new Error('Primary key and value required for delete');
-                        sql = "DELETE FROM `".concat(table, "` WHERE `").concat(key, "` = ?");
+                        sql = "DELETE\n                     FROM `".concat(table, "`\n                     WHERE `").concat(key, "` = ?");
                         console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated DELETE SQL:", sql);
                         console.log("[SQL EXECUTOR] \uD83D\uDD22 Value:", args[key]);
                         return [4 /*yield*/, this.withConnection(function (conn) { return tslib.__awaiter(_this, void 0, void 0, function () {
@@ -1556,7 +1777,13 @@ var SqlExecutor = /** @class */ (function (_super) {
                                         case 0: return [4 /*yield*/, conn.execute(sql, [args[key]])];
                                         case 1:
                                             result = (_a.sent())[0];
-                                            return [2 /*return*/, result];
+                                            return [2 /*return*/, {
+                                                    rest: result,
+                                                    sql: {
+                                                        sql: sql,
+                                                        args: args
+                                                    }
+                                                }];
                                     }
                                 });
                             }); })];
@@ -1566,23 +1793,35 @@ var SqlExecutor = /** @class */ (function (_super) {
         });
     };
     SqlExecutor.prototype.formatSQLWithParams = function (sql, params) {
-        var index = 0;
-        return sql.replace(/\?/g, function () {
-            if (index >= params.length)
-                return '?'; // fallback if params are missing
-            var val = params[index++];
-            if (val === null || val === undefined)
-                return 'NULL';
-            if (Buffer.isBuffer(val))
-                return "UNHEX('".concat(val.toString('hex'), "')");
-            if (typeof val === 'string')
-                return "'".concat(val.replace(/'/g, "''"), "'");
-            if (typeof val === 'number')
-                return val.toString();
-            if (val instanceof Date)
-                return "'".concat(val.toISOString().slice(0, 19).replace('T', ' '), "'");
-            return "'".concat(JSON.stringify(val), "'");
-        });
+        var _this = this;
+        if (Array.isArray(params)) {
+            var index_1 = 0;
+            return sql.replace(/\?/g, function () {
+                if (index_1 >= params.length)
+                    return '?';
+                var val = params[index_1++];
+                return _this.formatValue(val);
+            });
+        }
+        else {
+            return sql.replace(/:([a-zA-Z0-9_]+)/g, function (_, key) {
+                var val = params[key];
+                return _this.formatValue(val);
+            });
+        }
+    };
+    SqlExecutor.prototype.formatValue = function (val) {
+        if (val === null || val === undefined)
+            return 'NULL';
+        if (buffer.Buffer.isBuffer(val))
+            return "UNHEX('".concat(val.toString('hex'), "')");
+        if (typeof val === 'string')
+            return "'".concat(val.replace(/'/g, "''"), "'");
+        if (typeof val === 'number')
+            return val.toString();
+        if (val instanceof Date)
+            return "'".concat(val.toISOString().slice(0, 19).replace('T', ' '), "'");
+        return "'".concat(JSON.stringify(val), "'");
     };
     return SqlExecutor;
 }(SqlBuilder));
@@ -1636,11 +1875,11 @@ function ExpressHandler(_a) {
                         })(payload)];
                 case 1:
                     response = _a.sent();
-                    console.log('response', JSON.stringify(response));
                     res.status(200).json(tslib.__assign({ success: true }, response));
                     return [3 /*break*/, 3];
                 case 2:
                     err_1 = _a.sent();
+                    res.status(500).json({ success: false });
                     next(err_1);
                     return [3 /*break*/, 3];
                 case 3: return [2 /*return*/];