@carbonorm/carbonnode 3.0.15 → 3.1.3

package/dist/index.cjs.js

@@ -92,6 +92,37 @@ var C6Constants = {
     SECOND: 'SECOND',
     SECOND_MICROSECOND: 'SECOND_MICROSECOND',
     SELECT: 'SELECT',
+    // MySQL Spatial Functions
+    ST_AREA: 'ST_Area',
+    ST_ASBINARY: 'ST_AsBinary',
+    ST_ASTEXT: 'ST_AsText',
+    ST_BUFFER: 'ST_Buffer',
+    ST_CONTAINS: 'ST_Contains',
+    ST_CROSSES: 'ST_Crosses',
+    ST_DIFFERENCE: 'ST_Difference',
+    ST_DIMENSION: 'ST_Dimension',
+    ST_DISJOINT: 'ST_Disjoint',
+    ST_DISTANCE: 'ST_Distance',
+    ST_DISTANCE_SPHERE: 'ST_Distance_Sphere',
+    ST_ENDPOINT: 'ST_EndPoint',
+    ST_ENVELOPE: 'ST_Envelope',
+    ST_EQUALS: 'ST_Equals',
+    ST_GEOMFROMGEOJSON: 'ST_GeomFromGeoJSON',
+    ST_GEOMFROMTEXT: 'ST_GeomFromText',
+    ST_GEOMFROMWKB: 'ST_GeomFromWKB',
+    ST_INTERSECTS: 'ST_Intersects',
+    ST_LENGTH: 'ST_Length',
+    ST_OVERLAPS: 'ST_Overlaps',
+    ST_POINT: 'ST_Point',
+    ST_SETSRID: 'ST_SetSRID',
+    ST_SRID: 'ST_SRID',
+    ST_STARTPOINT: 'ST_StartPoint',
+    ST_SYMDIFFERENCE: 'ST_SymDifference',
+    ST_TOUCHES: 'ST_Touches',
+    ST_UNION: 'ST_Union',
+    ST_WITHIN: 'ST_Within',
+    ST_X: 'ST_X',
+    ST_Y: 'ST_Y',
     STR_TO_DATE: 'STR_TO_DATE',
     SUBDATE: 'SUBDATE',
     SUBTIME: 'SUBTIME',
@@ -134,6 +165,7 @@ var C6Constants = {
     FINISH: 'FINISH',
     VALIDATE_C6_ENTITY_ID_REGEX: '#^([a-fA-F0-9]{20,35})$#',
 };
+var C6C = C6Constants;
 
 // @link https://www.npmjs.com/package/axios-cache-adapter
 // updating these values
@@ -392,9 +424,11 @@ function isVerbose () {
 }
 
 var Executor = /** @class */ (function () {
-    function Executor(config, request) {
+    function Executor(config, request, useNamedParams) {
+        if (useNamedParams === void 0) { useNamedParams = false; }
         this.config = config;
         this.request = request;
+        this.useNamedParams = useNamedParams;
     }
     Executor.prototype.runLifecycleHooks = function (phase, args) {
         return tslib.__awaiter(this, void 0, void 0, function () {
@@ -424,8 +458,10 @@ var Executor = /** @class */ (function () {
                         _d.label = 2;
                     case 2:
                         _d.trys.push([2, 4, , 5]);
+                        // todo - this
                         return [4 /*yield*/, fn(args)];
                     case 3:
+                        // todo - this
                         _d.sent();
                         return [3 /*break*/, 5];
                     case 4:
@@ -443,408 +479,6 @@ var Executor = /** @class */ (function () {
     return Executor;
 }());
 
-var SqlBuilder = /** @class */ (function (_super) {
-    tslib.__extends(SqlBuilder, _super);
-    function SqlBuilder() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        /** Flag to determine if named placeholders should be used */
-        _this.useNamedParams = false;
-        return _this;
-    }
-    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',
-            '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 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)) {
-            // 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 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 (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.length ? parts.join(" ".concat(booleanOperator, " ")) : '';
-        }
-        else {
-            // Primitive type (should not happen normally), treat it as a boolean expression string
-            sql = String(set);
-        }
-        // Wrap the final combined condition in parentheses to maintain correct precedence
-        return sql ? "(".concat(sql, ")") : '';
-    };
-    /** Translate array or function call definitions into SQL expressions (supports nested calls) */
-    SqlBuilder.prototype.buildAggregateField = function (field) {
-        var _this = this;
-        if (typeof field === 'string') {
-            return field;
-        }
-        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;
-        // 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();
-        // 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':
-            case 'DATE_SUB':
-                // Functions with comma-separated interval, assume args like [ date, interval_expression ]
-                expr = "".concat(F, "(").concat(argList, ")");
-                break;
-            case 'YEAR':
-            case 'MONTH':
-            case 'DAY':
-            case 'ROUND':
-            case 'CEIL':
-            case 'FLOOR':
-            case 'ABS':
-            case 'SQRT':
-            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':
-                expr = "ST_Distance(".concat(argList, ")");
-                break;
-            default:
-                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 '';
-    };
-    SqlBuilder.prototype.buildSelectQuery = function (table, primary, args, isSubSelect) {
-        var _this = this;
-        var _a, _b, _c;
-        if (isSubSelect === void 0) { isSubSelect = false; }
-        var model = this.config.C6.TABLES[table];
-        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);
-        if (args === null || args === void 0 ? void 0 : args[C6Constants.JOIN]) {
-            sql += this.buildJoinClauses(args[C6Constants.JOIN], params);
-        }
-        if (args === null || args === void 0 ? void 0 : args[C6Constants.WHERE]) {
-            sql += this.buildWhereClause(args[C6Constants.WHERE], params);
-        }
-        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] ".concat(gb));
-        }
-        if (args === null || args === void 0 ? void 0 : args[C6Constants.HAVING]) {
-            var havingClause = this.buildBooleanJoinedConditions(args[C6Constants.HAVING], true, params);
-            if (havingClause) {
-                sql += " HAVING ".concat(havingClause);
-            }
-        }
-        if (args === null || args === void 0 ? void 0 : args[C6Constants.PAGINATION]) {
-            sql += this.buildPaginationClause(args[C6Constants.PAGINATION], params);
-        }
-        else if (!isSubSelect) {
-            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 (orderKey) {
-                var dir = primary ? 'ASC' : 'DESC';
-                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("[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));
-                }
-            }
-        }
-        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;
-}(Executor));
-
 function isLocal () {
     return getEnvVar('NODE_ENV', '') === 'development';
 }
@@ -1563,6 +1197,263 @@ var HttpExecutor$1 = /*#__PURE__*/Object.freeze({
     HttpExecutor: HttpExecutor
 });
 
+function convertHexIfBinary(_col, val, columnDef) {
+    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;
+}
+
+var AggregateBuilder = /** @class */ (function (_super) {
+    tslib.__extends(AggregateBuilder, _super);
+    function AggregateBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AggregateBuilder.prototype.buildAggregateField = function (field) {
+        var _this = this;
+        if (typeof field === 'string') {
+            return field;
+        }
+        if (!Array.isArray(field) || field.length === 0) {
+            throw new Error('Invalid SELECT field entry');
+        }
+        var fn = field[0], args = field.slice(1);
+        var alias;
+        if (args.length >= 2 && String(args[args.length - 2]).toUpperCase() === 'AS') {
+            alias = String(args.pop());
+            args.pop();
+        }
+        var F = String(fn).toUpperCase();
+        var argList = args.map(function (arg) {
+            return Array.isArray(arg) ? _this.buildAggregateField(arg) : arg;
+        }).join(', ');
+        var expr = "".concat(F, "(").concat(argList, ")");
+        if (alias) {
+            expr += " AS ".concat(alias);
+        }
+        isVerbose() && console.log("[SELECT] ".concat(expr));
+        return expr;
+    };
+    return AggregateBuilder;
+}(Executor));
+
+var ConditionBuilder = /** @class */ (function (_super) {
+    tslib.__extends(ConditionBuilder, _super);
+    function ConditionBuilder() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.OPERATORS = new Set([
+            '=', '!=', '<', '<=', '>', '>=',
+            'LIKE', 'NOT LIKE', 'IN', 'NOT IN',
+            'IS', 'IS NOT', 'BETWEEN', 'NOT BETWEEN',
+            C6Constants.MATCH_AGAINST
+        ]);
+        return _this;
+    }
+    ConditionBuilder.prototype.execute = function () {
+        throw new Error("Method not implemented.");
+    };
+    ConditionBuilder.prototype.validateOperator = function (op) {
+        if (!this.OPERATORS.has(op)) {
+            throw new Error("Invalid or unsupported SQL operator detected: '".concat(op, "'"));
+        }
+    };
+    ConditionBuilder.prototype.addParam = function (params, column, value) {
+        var _a, _b;
+        var columnDef = (_b = (_a = this.config.C6[column.split('.')[0]]) === null || _a === void 0 ? void 0 : _a.TYPE_VALIDATION) === null || _b === void 0 ? void 0 : _b[column];
+        var val = convertHexIfBinary(column, value, columnDef);
+        if (this.useNamedParams) {
+            var key = "param".concat(Object.keys(params).length);
+            params[key] = val;
+            return ":".concat(key);
+        }
+        else {
+            params.push(val);
+            return '?';
+        }
+    };
+    ConditionBuilder.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 addCondition = function (column, op, value) {
+            _this.validateOperator(op);
+            if (op === C6Constants.MATCH_AGAINST && Array.isArray(value)) {
+                var search = value[0], mode = value[1];
+                var paramName = _this.useNamedParams ? "param".concat(Object.keys(params).length) : null;
+                if (_this.useNamedParams) {
+                    params[paramName] = search;
+                }
+                else {
+                    params.push(search);
+                }
+                var againstClause = void 0;
+                switch ((mode || '').toUpperCase()) {
+                    case 'BOOLEAN':
+                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, " IN BOOLEAN MODE)") : "AGAINST(? IN BOOLEAN MODE)";
+                        break;
+                    case 'WITH QUERY EXPANSION':
+                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, " WITH QUERY EXPANSION)") : "AGAINST(? WITH QUERY EXPANSION)";
+                        break;
+                    default: // NATURAL or undefined
+                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, ")") : "AGAINST(?)";
+                        break;
+                }
+                var matchClause = "(MATCH(".concat(column, ") ").concat(againstClause, ")");
+                isVerbose() && console.log("[MATCH_AGAINST] ".concat(matchClause));
+                return matchClause;
+            }
+            // handle other operators
+            return "( ".concat(column, " ").concat(op, " ").concat(_this.addParam(params, column, value), " )");
+        };
+        var parts = [];
+        if (typeof set === 'object' && !Array.isArray(set)) {
+            for (var _i = 0, _a = Object.entries(set); _i < _a.length; _i++) {
+                var _b = _a[_i], key = _b[0], value = _b[1];
+                if (typeof value === 'object' && value !== null && Object.keys(value).length === 1) {
+                    var _c = Object.entries(value)[0], op = _c[0], val = _c[1];
+                    parts.push(addCondition(key, op, val));
+                }
+                else {
+                    parts.push(addCondition(key, '=', value));
+                }
+            }
+        }
+        var clause = parts.join(" ".concat(booleanOperator, " "));
+        return clause ? "(".concat(clause, ")") : '';
+    };
+    ConditionBuilder.prototype.buildWhereClause = function (whereArg, params) {
+        var clause = this.buildBooleanJoinedConditions(whereArg, true, params);
+        if (!clause)
+            return '';
+        var trimmed = clause.replace(/^\((.*)\)$/, '$1');
+        isVerbose() && console.log("[WHERE] ".concat(trimmed));
+        return " WHERE ".concat(trimmed);
+    };
+    return ConditionBuilder;
+}(AggregateBuilder));
+
+var JoinBuilder = /** @class */ (function (_super) {
+    tslib.__extends(JoinBuilder, _super);
+    function JoinBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    JoinBuilder.prototype.buildJoinClauses = function (joinArgs, params) {
+        var sql = '';
+        for (var joinType in joinArgs) {
+            var joinKind = joinType.replace('_', ' ').toUpperCase();
+            for (var raw in joinArgs[joinType]) {
+                var _a = raw.split(' '), table = _a[0], alias = _a[1];
+                var onClause = this.buildBooleanJoinedConditions(joinArgs[joinType][raw], true, params);
+                var joinSql = alias ? "`".concat(table, "` AS `").concat(alias, "`") : "`".concat(table, "`");
+                sql += " ".concat(joinKind, " JOIN ").concat(joinSql, " ON ").concat(onClause);
+            }
+        }
+        isVerbose() && console.log("[JOIN] ".concat(sql.trim()));
+        return sql;
+    };
+    return JoinBuilder;
+}(ConditionBuilder));
+
+var PaginationBuilder = /** @class */ (function (_super) {
+    tslib.__extends(PaginationBuilder, _super);
+    function PaginationBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * MySQL ORDER/LIMIT/OFFSET generator.
+     *
+     * Accepted structures:
+     * ```ts
+     * ORDER: {
+     *   // simple column with direction
+     *   [property_units.UNIT_ID]: "DESC",
+     *	 // function call (array of arguments)
+     *   [C6Constants.ST_DISTANCE_SPHERE]: [property_units.LOCATION, F(property_units.LOCATION, "pu_target")]
+     * }
+     * ```
+     */
+    PaginationBuilder.prototype.buildPaginationClause = function (pagination) {
+        var _this = this;
+        var _a;
+        var sql = "";
+        /* -------- ORDER BY -------- */
+        if (pagination === null || pagination === void 0 ? void 0 : pagination[C6Constants.ORDER]) {
+            var orderParts = [];
+            for (var _i = 0, _b = Object.entries(pagination[C6Constants.ORDER]); _i < _b.length; _i++) {
+                var _c = _b[_i], key = _c[0], val = _c[1];
+                // FUNCTION CALL: val is an array of args
+                if (Array.isArray(val)) {
+                    var args = val
+                        .map(function (arg) { return Array.isArray(arg) ? _this.buildAggregateField(arg) : String(arg); })
+                        .join(", ");
+                    orderParts.push("".concat(key, "(").concat(args, ")"));
+                }
+                // SIMPLE COLUMN + DIR (ASC/DESC)
+                else {
+                    orderParts.push("".concat(key, " ").concat(String(val).toUpperCase()));
+                }
+            }
+            if (orderParts.length)
+                sql += " ORDER BY ".concat(orderParts.join(", "));
+        }
+        /* -------- LIMIT / OFFSET -------- */
+        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("[PAGINATION] ".concat(sql.trim()));
+        return sql;
+    };
+    return PaginationBuilder;
+}(JoinBuilder));
+
+var SelectQueryBuilder = /** @class */ (function (_super) {
+    tslib.__extends(SelectQueryBuilder, _super);
+    function SelectQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SelectQueryBuilder.prototype.build = function (table, args, primary, isSubSelect) {
+        var _this = this;
+        var _a;
+        if (isSubSelect === void 0) { isSubSelect = false; }
+        var params = this.useNamedParams ? {} : [];
+        var selectList = (_a = args.SELECT) !== null && _a !== void 0 ? _a : ['*'];
+        var selectFields = selectList
+            .map(function (f) { return _this.buildAggregateField(f); })
+            .join(', ');
+        var sql = "SELECT ".concat(selectFields, " FROM `").concat(table, "`");
+        if (args.JOIN) {
+            sql += this.buildJoinClauses(args.JOIN, params);
+        }
+        if (args.WHERE) {
+            sql += this.buildWhereClause(args.WHERE, params);
+        }
+        if (args.GROUP_BY) {
+            var groupBy = Array.isArray(args.GROUP_BY)
+                ? args.GROUP_BY.join(', ')
+                : args.GROUP_BY;
+            sql += " GROUP BY ".concat(groupBy);
+        }
+        if (args.HAVING) {
+            sql += " HAVING ".concat(this.buildBooleanJoinedConditions(args.HAVING, true, params));
+        }
+        if (args.PAGINATION) {
+            sql += this.buildPaginationClause(args.PAGINATION);
+        }
+        else if (!isSubSelect) {
+            sql += primary ? " ORDER BY ".concat(primary, " ASC LIMIT 1") : " LIMIT 100";
+        }
+        return { sql: sql, params: params };
+    };
+    return SelectQueryBuilder;
+}(PaginationBuilder));
+
 var SqlExecutor = /** @class */ (function (_super) {
     tslib.__extends(SqlExecutor, _super);
     function SqlExecutor() {
@@ -1655,7 +1546,7 @@ var SqlExecutor = /** @class */ (function (_super) {
             return tslib.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        QueryResult = this.buildSelectQuery(table, primary, args);
+                        QueryResult = (new SelectQueryBuilder(this.config, this.request)).build(table, args, primary);
                         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);
@@ -1824,7 +1715,7 @@ var SqlExecutor = /** @class */ (function (_super) {
         return "'".concat(JSON.stringify(val), "'");
     };
     return SqlExecutor;
-}(SqlBuilder));
+}(Executor));
 
 var SqlExecutor$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1879,7 +1770,7 @@ function ExpressHandler(_a) {
                     return [3 /*break*/, 3];
                 case 2:
                     err_1 = _a.sent();
-                    res.status(500).json({ success: false });
+                    res.status(500).json({ success: false, error: err_1 });
                     next(err_1);
                     return [3 /*break*/, 3];
                 case 3: return [2 /*return*/];
@@ -1888,6 +1779,85 @@ function ExpressHandler(_a) {
     }); };
 }
 
+// Alias a table name with a given alias
+var A = function (tableName, alias) {
+    return "".concat(tableName, " ").concat(alias);
+};
+// Qualify a column constant (e.g. 'property_units.parcel_id') to an alias
+var F = function (qualifiedCol, alias) {
+    return "".concat(alias, ".").concat(qualifiedCol.split('.').pop());
+};
+// Equal join condition using full-qualified column constants
+var fieldEq = function (leftCol, rightCol, leftAlias, rightAlias) {
+    var _a;
+    return (_a = {},
+        _a[F(leftCol, leftAlias)] = F(rightCol, rightAlias),
+        _a);
+};
+// ST_Distance_Sphere for aliased fields
+var distSphere = function (fromCol, toCol, fromAlias, toAlias) {
+    return [C6C.ST_DISTANCE_SPHERE, F(fromCol, fromAlias), F(toCol, toAlias)];
+};
+
+var DeleteQueryBuilder = /** @class */ (function (_super) {
+    tslib.__extends(DeleteQueryBuilder, _super);
+    function DeleteQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DeleteQueryBuilder.prototype.build = function (table, args) {
+        if (args === void 0) { args = {}; }
+        var params = this.useNamedParams ? {} : [];
+        var sql = args.JOIN ? "DELETE ".concat(table, "\n                               FROM `").concat(table, "`") : "DELETE\n                                                     FROM `".concat(table, "`");
+        if (args.JOIN) {
+            sql += this.buildJoinClauses(args.JOIN, params);
+        }
+        if (args.WHERE) {
+            sql += this.buildWhereClause(args.WHERE, params);
+        }
+        if (args.PAGINATION) {
+            sql += this.buildPaginationClause(args.PAGINATION);
+        }
+        return { sql: sql, params: params };
+    };
+    return DeleteQueryBuilder;
+}(PaginationBuilder));
+
+var UpdateQueryBuilder = /** @class */ (function (_super) {
+    tslib.__extends(UpdateQueryBuilder, _super);
+    function UpdateQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UpdateQueryBuilder.prototype.build = function (table, data, args) {
+        if (args === void 0) { args = {}; }
+        var params = this.useNamedParams ? {} : [];
+        var sql = "UPDATE `".concat(table, "`");
+        if (args.JOIN) {
+            sql += this.buildJoinClauses(args.JOIN, params);
+        }
+        var setClauses = Object.entries(data).map(function (_a) {
+            var col = _a[0], val = _a[1];
+            if (Array.isArray(params)) {
+                params.push(val);
+                return "`".concat(col, "` = ?");
+            }
+            else {
+                var key = "param".concat(Object.keys(params).length);
+                params[key] = val;
+                return "`".concat(col, "` = :").concat(key);
+            }
+        });
+        sql += " SET ".concat(setClauses.join(', '));
+        if (args.WHERE) {
+            sql += this.buildWhereClause(args.WHERE, params);
+        }
+        if (args.PAGINATION) {
+            sql += this.buildPaginationClause(args.PAGINATION);
+        }
+        return { sql: sql, params: params };
+    };
+    return UpdateQueryBuilder;
+}(PaginationBuilder));
+
 function determineRuntimeJsType(mysqlType) {
     var base = mysqlType.toLowerCase().split('(')[0];
     if ([
@@ -1986,24 +1956,36 @@ function onError(message) {
     reactToastify.toast.error(message, isLocal() ? toastOptionsDevs : toastOptions);
 }
 
+exports.A = A;
+exports.AggregateBuilder = AggregateBuilder;
+exports.C6C = C6C;
 exports.C6Constants = C6Constants;
+exports.ConditionBuilder = ConditionBuilder;
 exports.DELETE = DELETE;
+exports.DeleteQueryBuilder = DeleteQueryBuilder;
 exports.Executor = Executor;
 exports.ExpressHandler = ExpressHandler;
+exports.F = F;
 exports.GET = GET;
 exports.HttpExecutor = HttpExecutor;
+exports.JoinBuilder = JoinBuilder;
 exports.POST = POST;
 exports.PUT = PUT;
-exports.SqlBuilder = SqlBuilder;
+exports.PaginationBuilder = PaginationBuilder;
+exports.SelectQueryBuilder = SelectQueryBuilder;
 exports.SqlExecutor = SqlExecutor;
 exports.TestRestfulResponse = TestRestfulResponse;
+exports.UpdateQueryBuilder = UpdateQueryBuilder;
 exports.axiosInstance = axiosInstance;
 exports.checkAllRequestsComplete = checkAllRequestsComplete;
 exports.checkCache = checkCache;
 exports.clearCache = clearCache;
 exports.convertForRequestBody = convertForRequestBody;
+exports.convertHexIfBinary = convertHexIfBinary;
 exports.determineRuntimeJsType = determineRuntimeJsType;
+exports.distSphere = distSphere;
 exports.error = error;
+exports.fieldEq = fieldEq;
 exports.getEnvVar = getEnvVar;
 exports.getPrimaryKeyTypes = getPrimaryKeyTypes;
 exports.group = group;