@carbonorm/carbonnode 6.0.20 → 6.1.1

package/dist/index.esm.js

@@ -160,6 +160,7 @@ var C6Constants = {
     AND: 'AND',
     BETWEEN: 'BETWEEN',
     CONCAT: 'CONCAT',
+    CALL: 'CALL',
     CONVERT_TZ: 'CONVERT_TZ',
     COUNT: 'COUNT',
     COUNT_ALL: 'COUNT_ALL',
@@ -214,6 +215,7 @@ var C6Constants = {
     LESS_THAN: '<',
     LESS_THAN_OR_EQUAL_TO: '<=',
     LIKE: 'LIKE',
+    LIT: 'LIT',
     LIMIT: 'LIMIT',
     LOCALTIME: 'LOCALTIME',
     LOCALTIMESTAMP: 'LOCALTIMESTAMP',
@@ -951,7 +953,7 @@ function colorSql(sql) {
     return s;
 }
 
-var version = "6.0.20";
+var version = "6.1.1";
 
 var DEFAULT_STEP = 8;
 function parseSemver(version) {
@@ -1288,16 +1290,16 @@ var HttpExecutor = /** @class */ (function (_super) {
                         }
                         query = this.request;
                         apiRequest = function () { return __awaiter(_this, void 0, void 0, function () {
-                            var _a, debug, _b, cacheResults, dataInsertMultipleRows, success, _c, fetchDependencies, _d, error, cachingConfirmed, cacheRequestData, cacheAllowListStatus, evictFromCache, querySerialized, cachedRequest, cachedData, apiResponse, restRequestUri, needsConditionOrPrimaryCheck, TABLES, primaryKeyList, primaryKeyFullyQualified, primaryKey, whereVal, whereIsEmpty, providedPrimary, primaryVal, axiosActiveRequest_1;
-                            var _e;
+                            var _a, debug, _b, cacheResults, _c, skipReactBootstrap, dataInsertMultipleRows, success, _d, fetchDependencies, _e, error, cachingConfirmed, cacheRequestData, cacheAllowListStatus, evictFromCache, querySerialized, cachedRequest, cachedData, apiResponse, restRequestUri, needsConditionOrPrimaryCheck, TABLES, primaryKeyList, primaryKeyFullyQualified, primaryKey, whereVal, whereIsEmpty, providedPrimary, primaryVal, axiosActiveRequest_1;
+                            var _f;
                             var _this = this;
-                            var _f, _g, _h, _j, _k, _l;
-                            return __generator(this, function (_m) {
-                                switch (_m.label) {
+                            var _g, _h, _j, _k, _l, _m;
+                            return __generator(this, function (_o) {
+                                switch (_o.label) {
                                     case 0:
-                                        _a = this.request, debug = _a.debug, _b = _a.cacheResults, cacheResults = _b === void 0 ? (C6.GET === requestMethod) : _b, dataInsertMultipleRows = _a.dataInsertMultipleRows, success = _a.success, _c = _a.fetchDependencies, fetchDependencies = _c === void 0 ? eFetchDependencies.NONE : _c, _d = _a.error, error = _d === void 0 ? "An unexpected API error occurred!" : _d;
+                                        _a = this.request, debug = _a.debug, _b = _a.cacheResults, cacheResults = _b === void 0 ? (C6.GET === requestMethod) : _b, _c = _a.skipReactBootstrap, skipReactBootstrap = _c === void 0 ? false : _c, dataInsertMultipleRows = _a.dataInsertMultipleRows, success = _a.success, _d = _a.fetchDependencies, fetchDependencies = _d === void 0 ? eFetchDependencies.NONE : _d, _e = _a.error, error = _e === void 0 ? "An unexpected API error occurred!" : _e;
                                         if (C6.GET === requestMethod
-                                            && undefined !== ((_f = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _f === void 0 ? void 0 : _f[C6.PAGE])
+                                            && undefined !== ((_g = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _g === void 0 ? void 0 : _g[C6.PAGE])
                                             && 1 !== query[C6.PAGINATION][C6.PAGE]
                                             && isLocal()
                                             && shouldLog(LogLevel.DEBUG, logContext)) {
@@ -1332,7 +1334,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                         if (!cachedRequest) return [3 /*break*/, 2];
                                         return [4 /*yield*/, cachedRequest];
                                     case 1:
-                                        cachedData = (_m.sent()).data;
+                                        cachedData = (_o.sent()).data;
                                         if (evictFromCache
                                             && cachedData
                                             && typeof cachedData === "object"
@@ -1354,9 +1356,9 @@ var HttpExecutor = /** @class */ (function (_super) {
                                         needsConditionOrPrimaryCheck = (PUT === requestMethod || DELETE === requestMethod)
                                             && false === skipPrimaryCheck;
                                         TABLES = C6.TABLES;
-                                        primaryKeyList = structuredClone((_g = TABLES[operatingTable]) === null || _g === void 0 ? void 0 : _g.PRIMARY);
+                                        primaryKeyList = structuredClone((_h = TABLES[operatingTable]) === null || _h === void 0 ? void 0 : _h.PRIMARY);
                                         primaryKeyFullyQualified = primaryKeyList === null || primaryKeyList === void 0 ? void 0 : primaryKeyList.pop();
-                                        primaryKey = (_h = primaryKeyFullyQualified === null || primaryKeyFullyQualified === void 0 ? void 0 : primaryKeyFullyQualified.split('.')) === null || _h === void 0 ? void 0 : _h.pop();
+                                        primaryKey = (_j = primaryKeyFullyQualified === null || primaryKeyFullyQualified === void 0 ? void 0 : primaryKeyFullyQualified.split('.')) === null || _j === void 0 ? void 0 : _j.pop();
                                         if (needsConditionOrPrimaryCheck) {
                                             if (undefined === primaryKey) {
                                                 whereVal = query === null || query === void 0 ? void 0 : query[C6.WHERE];
@@ -1365,7 +1367,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                     (typeof whereVal === 'object' && !Array.isArray(whereVal) && Object.keys(whereVal).length === 0);
                                                 if (whereIsEmpty) {
                                                     logWithLevel(LogLevel.ERROR, logContext, console.error, query);
-                                                    throw Error('Failed to parse primary key information. Query: (' + JSON.stringify(query) + ') Primary Key: (' + JSON.stringify(primaryKey) + ') TABLES[operatingTable]?.PRIMARY: (' + JSON.stringify((_j = TABLES[operatingTable]) === null || _j === void 0 ? void 0 : _j.PRIMARY) + ') for operatingTable (' + operatingTable + ').');
+                                                    throw Error('Failed to parse primary key information. Query: (' + JSON.stringify(query) + ') Primary Key: (' + JSON.stringify(primaryKey) + ') TABLES[operatingTable]?.PRIMARY: (' + JSON.stringify((_k = TABLES[operatingTable]) === null || _k === void 0 ? void 0 : _k.PRIMARY) + ') for operatingTable (' + operatingTable + ').');
                                                 }
                                             }
                                             else {
@@ -1377,7 +1379,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                     }
                                                     throw Error('You must provide the primary key (' + primaryKey + ') for table (' + operatingTable + '). Request (' + JSON.stringify(this.request, undefined, 4) + ') Query (' + JSON.stringify(query) + ')');
                                                 }
-                                                providedPrimary = (_k = query === null || query === void 0 ? void 0 : query[primaryKey]) !== null && _k !== void 0 ? _k : (primaryKeyFullyQualified ? query === null || query === void 0 ? void 0 : query[primaryKeyFullyQualified] : undefined);
+                                                providedPrimary = (_l = query === null || query === void 0 ? void 0 : query[primaryKey]) !== null && _l !== void 0 ? _l : (primaryKeyFullyQualified ? query === null || query === void 0 ? void 0 : query[primaryKeyFullyQualified] : undefined);
                                                 if (undefined === providedPrimary || null === providedPrimary) {
                                                     notifyToast("error", "The primary key (".concat(primaryKey, ") provided is undefined or null explicitly!!"));
                                                     throw Error('The primary key (' + primaryKey + ') provided in the request was exactly equal to undefined.');
@@ -1391,7 +1393,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                             && undefined !== query
                                             && null !== query
                                             && undefined !== primaryKey) {
-                                            primaryVal = (_l = query[primaryKey]) !== null && _l !== void 0 ? _l : (primaryKeyFullyQualified ? query[primaryKeyFullyQualified] : undefined);
+                                            primaryVal = (_m = query[primaryKey]) !== null && _m !== void 0 ? _m : (primaryKeyFullyQualified ? query[primaryKeyFullyQualified] : undefined);
                                             if (undefined !== primaryVal) {
                                                 restRequestUri += primaryVal + '/';
                                                 if (isLocal() && shouldLog(LogLevel.DEBUG, logContext)) {
@@ -1419,7 +1421,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                 config: this.config,
                                                 request: this.request
                                             });
-                                            axiosActiveRequest_1 = (_e = axios)[requestMethod.toLowerCase()].apply(_e, __spreadArray([restRequestUri], (function () {
+                                            axiosActiveRequest_1 = (_f = axios)[requestMethod.toLowerCase()].apply(_f, __spreadArray([restRequestUri], (function () {
                                                 var convert = function (data) {
                                                     return convertForRequestBody(data, fullTableList, C6, function (message) { return notifyToast("error", message, toastOptions); });
                                                 };
@@ -1508,7 +1510,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                     request: _this.request,
                                                                     response: response
                                                                 }); };
-                                                                if (undefined !== reactBootstrap && response) {
+                                                                if (undefined !== reactBootstrap && response && !skipReactBootstrap) {
                                                                     switch (requestMethod) {
                                                                         case GET:
                                                                             response.data && reactBootstrap.updateRestfulObjectArrays({
@@ -1796,15 +1798,489 @@ var HttpExecutor$1 = /*#__PURE__*/Object.freeze({
 });
 
 function convertHexIfBinary(_col, val, columnDef) {
+    var _a;
     if (typeof val === 'string' &&
         /^[0-9a-fA-F]{32}$/.test(val) &&
         typeof columnDef === 'object' &&
-        columnDef.MYSQL_TYPE.toUpperCase().includes('BINARY')) {
+        String((_a = columnDef.MYSQL_TYPE) !== null && _a !== void 0 ? _a : '').toUpperCase().includes('BINARY')) {
         return Buffer.from(val, 'hex');
     }
     return val;
 }
+var TEMPORAL_TYPES = new Set([
+    'date',
+    'datetime',
+    'timestamp',
+    'time',
+    'year',
+]);
+var MYSQL_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var MYSQL_DATETIME_REGEX = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d{1,6})?$/;
+var MYSQL_TIME_REGEX = /^-?\d{2,3}:\d{2}:\d{2}(?:\.\d{1,6})?$/;
+var ISO_DATETIME_REGEX = /^(\d{4}-\d{2}-\d{2})[Tt](\d{2}:\d{2}:\d{2})(\.\d{1,6})?([zZ]|[+-]\d{2}:\d{2})?$/;
+var pad2 = function (value) { return value.toString().padStart(2, '0'); };
+function trimFraction(value, precision) {
+    var _a = value.split('.', 2), base = _a[0], fractionRaw = _a[1];
+    if (precision <= 0 || !fractionRaw)
+        return base;
+    return "".concat(base, ".").concat(fractionRaw.slice(0, precision).padEnd(precision, '0'));
+}
+function normalizeFraction(raw, precision) {
+    if (precision <= 0)
+        return '';
+    if (!raw)
+        return '';
+    var digits = raw.startsWith('.') ? raw.slice(1) : raw;
+    return ".".concat(digits.slice(0, precision).padEnd(precision, '0'));
+}
+function formatDateUtc(value) {
+    return "".concat(value.getUTCFullYear(), "-").concat(pad2(value.getUTCMonth() + 1), "-").concat(pad2(value.getUTCDate()));
+}
+function formatTimeUtc(value, precision) {
+    var base = "".concat(pad2(value.getUTCHours()), ":").concat(pad2(value.getUTCMinutes()), ":").concat(pad2(value.getUTCSeconds()));
+    if (precision <= 0)
+        return base;
+    var millis = value.getUTCMilliseconds().toString().padStart(3, '0');
+    var fraction = millis.slice(0, Math.min(precision, 3)).padEnd(precision, '0');
+    return "".concat(base, ".").concat(fraction);
+}
+function formatDateTimeUtc(value, precision) {
+    return "".concat(formatDateUtc(value), " ").concat(formatTimeUtc(value, precision));
+}
+function parseEpochNumber(value) {
+    if (!Number.isFinite(value))
+        return undefined;
+    var abs = Math.abs(value);
+    if (abs >= 1e12) {
+        var date = new Date(value);
+        return Number.isNaN(date.getTime()) ? undefined : date;
+    }
+    if (abs >= 1e9) {
+        var date = new Date(value * 1000);
+        return Number.isNaN(date.getTime()) ? undefined : date;
+    }
+    return undefined;
+}
+function parseTemporalType(columnDef) {
+    var _a;
+    var raw = String((_a = columnDef === null || columnDef === void 0 ? void 0 : columnDef.MYSQL_TYPE) !== null && _a !== void 0 ? _a : '').trim().toLowerCase();
+    if (!raw)
+        return { baseType: undefined, precision: 0 };
+    var base = raw.split(/[\s(]/, 1)[0];
+    if (!TEMPORAL_TYPES.has(base))
+        return { baseType: undefined, precision: 0 };
+    var precisionMatch = raw.match(/^(?:datetime|timestamp|time)\((\d+)\)/);
+    if (!precisionMatch)
+        return { baseType: base, precision: 0 };
+    var parsed = Number.parseInt(precisionMatch[1], 10);
+    if (!Number.isFinite(parsed))
+        return { baseType: base, precision: 0 };
+    return { baseType: base, precision: Math.max(0, Math.min(6, parsed)) };
+}
+function normalizeTemporalString(value, baseType, precision) {
+    var trimmed = value.trim();
+    if (!trimmed)
+        return value;
+    if (baseType === 'date') {
+        if (MYSQL_DATE_REGEX.test(trimmed))
+            return trimmed;
+        var iso_1 = trimmed.match(ISO_DATETIME_REGEX);
+        if (iso_1) {
+            var datePart = iso_1[1], timezonePart = iso_1[4];
+            if (!timezonePart)
+                return datePart;
+            var parsed_1 = new Date(trimmed);
+            return Number.isNaN(parsed_1.getTime()) ? value : formatDateUtc(parsed_1);
+        }
+        var parsed_2 = new Date(trimmed);
+        return Number.isNaN(parsed_2.getTime()) ? value : formatDateUtc(parsed_2);
+    }
+    if (baseType === 'time') {
+        if (MYSQL_TIME_REGEX.test(trimmed))
+            return trimFraction(trimmed, precision);
+        var iso_2 = trimmed.match(ISO_DATETIME_REGEX);
+        if (iso_2) {
+            var timePart = iso_2[2], fractionPart = iso_2[3], timezonePart = iso_2[4];
+            if (!timezonePart) {
+                return "".concat(timePart).concat(normalizeFraction(fractionPart, precision));
+            }
+            var parsed_3 = new Date(trimmed);
+            return Number.isNaN(parsed_3.getTime()) ? value : formatTimeUtc(parsed_3, precision);
+        }
+        var parsed_4 = new Date(trimmed);
+        return Number.isNaN(parsed_4.getTime()) ? value : formatTimeUtc(parsed_4, precision);
+    }
+    if (baseType === 'year') {
+        if (/^\d{2,4}$/.test(trimmed))
+            return trimmed;
+        var parsed_5 = new Date(trimmed);
+        return Number.isNaN(parsed_5.getTime()) ? value : String(parsed_5.getUTCFullYear());
+    }
+    if (MYSQL_DATETIME_REGEX.test(trimmed))
+        return trimFraction(trimmed, precision);
+    var iso = trimmed.match(ISO_DATETIME_REGEX);
+    if (iso) {
+        var datePart = iso[1], timePart = iso[2], fractionPart = iso[3], timezonePart = iso[4];
+        if (!timezonePart) {
+            return "".concat(datePart, " ").concat(timePart).concat(normalizeFraction(fractionPart, precision));
+        }
+        var parsed_6 = new Date(trimmed);
+        return Number.isNaN(parsed_6.getTime()) ? value : formatDateTimeUtc(parsed_6, precision);
+    }
+    var parsed = new Date(trimmed);
+    return Number.isNaN(parsed.getTime()) ? value : formatDateTimeUtc(parsed, precision);
+}
+function convertTemporalIfNeeded(value, columnDef) {
+    var _a = parseTemporalType(columnDef), baseType = _a.baseType, precision = _a.precision;
+    if (!baseType)
+        return value;
+    if (value === null || value === undefined)
+        return value;
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value))
+        return value;
+    if (value instanceof Date) {
+        if (baseType === 'date')
+            return formatDateUtc(value);
+        if (baseType === 'time')
+            return formatTimeUtc(value, precision);
+        if (baseType === 'year')
+            return String(value.getUTCFullYear());
+        return formatDateTimeUtc(value, precision);
+    }
+    if (typeof value === 'number') {
+        var parsed = parseEpochNumber(value);
+        if (!parsed)
+            return value;
+        if (baseType === 'date')
+            return formatDateUtc(parsed);
+        if (baseType === 'time')
+            return formatTimeUtc(parsed, precision);
+        if (baseType === 'year')
+            return String(parsed.getUTCFullYear());
+        return formatDateTimeUtc(parsed, precision);
+    }
+    if (typeof value === 'string') {
+        return normalizeTemporalString(value, baseType, precision);
+    }
+    return value;
+}
+function convertSqlValueForColumn(col, val, columnDef) {
+    var binaryConverted = convertHexIfBinary(col, val, columnDef);
+    return convertTemporalIfNeeded(binaryConverted, columnDef);
+}
+
+// ========================
+// SQL Operators & Expressions
+// ========================
+var SQL_KNOWN_FUNCTIONS = [
+    'ADDDATE',
+    'ADDTIME',
+    'CONCAT',
+    'CONVERT_TZ',
+    'COUNT',
+    'COUNT_ALL',
+    'CURRENT_DATE',
+    'CURRENT_TIMESTAMP',
+    'DAY',
+    'DAY_HOUR',
+    'DAY_MICROSECOND',
+    'DAY_MINUTE',
+    'DAY_SECOND',
+    'DAYNAME',
+    'DAYOFMONTH',
+    'DAYOFWEEK',
+    'DAYOFYEAR',
+    'DATE',
+    'DATE_ADD',
+    'DATEDIFF',
+    'DATE_SUB',
+    'DATE_FORMAT',
+    'EXTRACT',
+    'FROM_DAYS',
+    'FROM_UNIXTIME',
+    'GET_FORMAT',
+    'GROUP_CONCAT',
+    'HEX',
+    'HOUR',
+    'HOUR_MICROSECOND',
+    'HOUR_MINUTE',
+    'HOUR_SECOND',
+    'INTERVAL',
+    'LOCALTIME',
+    'LOCALTIMESTAMP',
+    'MAKEDATE',
+    'MAKETIME',
+    'MAX',
+    'MBRContains',
+    'MICROSECOND',
+    'MIN',
+    'MINUTE',
+    'MINUTE_MICROSECOND',
+    'MINUTE_SECOND',
+    'MONTH',
+    'MONTHNAME',
+    'NOW',
+    'POINT',
+    'POLYGON',
+    'SECOND',
+    'SECOND_MICROSECOND',
+    'ST_Area',
+    'ST_AsBinary',
+    'ST_AsText',
+    'ST_Buffer',
+    'ST_Contains',
+    'ST_Crosses',
+    'ST_Difference',
+    'ST_Dimension',
+    'ST_Disjoint',
+    'ST_Distance',
+    'ST_Distance_Sphere',
+    'ST_EndPoint',
+    'ST_Envelope',
+    'ST_Equals',
+    'ST_GeomFromGeoJSON',
+    'ST_GeomFromText',
+    'ST_GeomFromWKB',
+    'ST_Intersects',
+    'ST_Length',
+    'ST_MakeEnvelope',
+    'ST_Overlaps',
+    'ST_Point',
+    'ST_SetSRID',
+    'ST_SRID',
+    'ST_StartPoint',
+    'ST_SymDifference',
+    'ST_Touches',
+    'ST_Union',
+    'ST_Within',
+    'ST_X',
+    'ST_Y',
+    'STR_TO_DATE',
+    'SUBDATE',
+    'SUBTIME',
+    'SUM',
+    'SYSDATE',
+    'TIME',
+    'TIME_FORMAT',
+    'TIME_TO_SEC',
+    'TIMEDIFF',
+    'TIMESTAMP',
+    'TIMESTAMPADD',
+    'TIMESTAMPDIFF',
+    'TO_DAYS',
+    'TO_SECONDS',
+    'TRANSACTION_TIMESTAMP',
+    'UNHEX',
+    'UNIX_TIMESTAMP',
+    'UTC_DATE',
+    'UTC_TIME',
+    'UTC_TIMESTAMP',
+    'WEEKDAY',
+    'WEEKOFYEAR',
+    'YEARWEEK',
+];
+
+var IDENTIFIER_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var isFiniteNumber = function (value) {
+    return typeof value === 'number' && Number.isFinite(value);
+};
+var normalizeToken = function (token) { return token.trim(); };
+var ensureParams = function (opts) {
+    if (!opts.params) {
+        throw new Error("".concat(opts.context, " requires parameter tracking for literal bindings."));
+    }
+    if (!opts.hooks.addParam) {
+        throw new Error("".concat(opts.context, " requires addParam support for literal bindings."));
+    }
+    return opts.params;
+};
+var serializeStringReference = function (raw, opts) {
+    var value = raw.trim();
+    if (value === '*') {
+        return {
+            sql: value,
+            isReference: true,
+            isExpression: false,
+            isSubSelect: false,
+        };
+    }
+    if (!opts.hooks.isReference(value)) {
+        throw new Error("Bare string '".concat(raw, "' is not a reference in ").concat(opts.context, ". Wrap literal strings with [C6C.LIT, value]."));
+    }
+    if (value.includes('.')) {
+        opts.hooks.assertValidIdentifier(value, opts.context);
+    }
+    return {
+        sql: value,
+        isReference: true,
+        isExpression: false,
+        isSubSelect: false,
+    };
+};
+var serializeLiteralValue = function (value, opts) {
+    var _a;
+    if (value === null || value === C6C.NULL) {
+        return {
+            sql: 'NULL',
+            isReference: false,
+            isExpression: false,
+            isSubSelect: false,
+        };
+    }
+    if (isFiniteNumber(value)) {
+        return {
+            sql: String(value),
+            isReference: false,
+            isExpression: false,
+            isSubSelect: false,
+        };
+    }
+    if (typeof value === 'boolean') {
+        return {
+            sql: value ? 'TRUE' : 'FALSE',
+            isReference: false,
+            isExpression: false,
+            isSubSelect: false,
+        };
+    }
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value)) {
+        var params = ensureParams(opts);
+        return {
+            sql: opts.hooks.addParam(params, (_a = opts.contextColumn) !== null && _a !== void 0 ? _a : '', value),
+            isReference: false,
+            isExpression: false,
+            isSubSelect: false,
+        };
+    }
+    throw new Error("Unsupported literal value in ".concat(opts.context, ". Use [C6C.LIT, value] for non-reference strings or complex values."));
+};
+var validateAlias = function (aliasRaw, context) {
+    if (typeof aliasRaw !== 'string' || aliasRaw.trim() === '') {
+        throw new Error("[C6C.AS] in ".concat(context, " expects a non-empty alias string."));
+    }
+    var alias = aliasRaw.trim();
+    if (!IDENTIFIER_REGEX.test(alias)) {
+        throw new Error("[C6C.AS] alias '".concat(alias, "' in ").concat(context, " must be a valid SQL identifier."));
+    }
+    return alias;
+};
+var validateFunctionName = function (nameRaw, context) {
+    if (typeof nameRaw !== 'string' || nameRaw.trim() === '') {
+        throw new Error("[C6C.CALL] in ".concat(context, " expects the custom function name as a non-empty string."));
+    }
+    var name = normalizeToken(nameRaw);
+    if (!IDENTIFIER_REGEX.test(name)) {
+        throw new Error("[C6C.CALL] function '".concat(name, "' in ").concat(context, " must be a valid SQL identifier."));
+    }
+    return name;
+};
+var serializeFunctionArgs = function (args, opts) { return args
+    .map(function (arg) { return serializeSqlExpression(arg, opts).sql; })
+    .join(', '); };
+var serializeSqlExpression = function (value, opts) {
+    var _a, _b, _c;
+    if (value instanceof Map) {
+        value = Object.fromEntries(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            throw new Error("Invalid empty expression array in ".concat(opts.context, "."));
+        }
+        var headRaw = value[0], tail = value.slice(1);
+        if (typeof headRaw !== 'string') {
+            throw new Error("Expression arrays in ".concat(opts.context, " must start with a string token."));
+        }
+        var head = normalizeToken(headRaw);
+        var token = head.toUpperCase();
+        if (token === C6C.AS) {
+            if (tail.length !== 2) {
+                throw new Error("[C6C.AS] in ".concat(opts.context, " expects [C6C.AS, expression, alias]."));
+            }
+            var inner = serializeSqlExpression(tail[0], opts);
+            var alias = validateAlias(tail[1], opts.context);
+            (_b = (_a = opts.hooks).onAlias) === null || _b === void 0 ? void 0 : _b.call(_a, alias);
+            return {
+                sql: "".concat(inner.sql, " AS ").concat(alias),
+                isReference: false,
+                isExpression: true,
+                isSubSelect: inner.isSubSelect,
+            };
+        }
+        if (token === C6C.DISTINCT) {
+            if (tail.length !== 1) {
+                throw new Error("[C6C.DISTINCT] in ".concat(opts.context, " expects [C6C.DISTINCT, expression]."));
+            }
+            var inner = serializeSqlExpression(tail[0], opts);
+            return {
+                sql: "DISTINCT ".concat(inner.sql),
+                isReference: false,
+                isExpression: true,
+                isSubSelect: inner.isSubSelect,
+            };
+        }
+        if (token === C6C.LIT || token === C6C.PARAM) {
+            if (tail.length !== 1) {
+                throw new Error("[".concat(head, "] in ").concat(opts.context, " expects [").concat(head, ", value]."));
+            }
+            var params = ensureParams(opts);
+            return {
+                sql: opts.hooks.addParam(params, (_c = opts.contextColumn) !== null && _c !== void 0 ? _c : '', tail[0]),
+                isReference: false,
+                isExpression: false,
+                isSubSelect: false,
+            };
+        }
+        if (token === C6C.SUBSELECT) {
+            if (tail.length !== 1) {
+                throw new Error("[C6C.SUBSELECT] in ".concat(opts.context, " expects [C6C.SUBSELECT, payload]."));
+            }
+            if (!opts.hooks.buildScalarSubSelect) {
+                throw new Error("Scalar subselects in ".concat(opts.context, " require subselect builder support."));
+            }
+            var params = ensureParams(opts);
+            var subSql = opts.hooks.buildScalarSubSelect(tail[0], params);
+            return {
+                sql: subSql,
+                isReference: false,
+                isExpression: true,
+                isSubSelect: true,
+            };
+        }
+        if (token === C6C.CALL) {
+            var fnNameRaw = tail[0], args = tail.slice(1);
+            var fnName = validateFunctionName(fnNameRaw, opts.context);
+            var sqlArgs_1 = serializeFunctionArgs(args, opts);
+            return {
+                sql: "".concat(fnName, "(").concat(sqlArgs_1, ")"),
+                isReference: false,
+                isExpression: true,
+                isSubSelect: false,
+            };
+        }
+        if (tail.length >= 2 && String(tail[tail.length - 2]).toUpperCase() === C6C.AS) {
+            throw new Error("Legacy positional AS syntax is not supported in ".concat(opts.context, ". Use [C6C.AS, expression, alias]."));
+        }
+        if (opts.hooks.isKnownFunction && !opts.hooks.isKnownFunction(head)) {
+            throw new Error("Unknown SQL function '".concat(head, "' in ").concat(opts.context, ". Use [C6C.CALL, 'FUNCTION_NAME', ...args] for custom functions."));
+        }
+        var sqlArgs = serializeFunctionArgs(tail, opts);
+        return {
+            sql: "".concat(token, "(").concat(sqlArgs, ")"),
+            isReference: false,
+            isExpression: true,
+            isSubSelect: false,
+        };
+    }
+    if (typeof value === 'string') {
+        return serializeStringReference(value, opts);
+    }
+    if (value && typeof value === 'object') {
+        throw new Error("Object-rooted expressions are not supported in ".concat(opts.context, ". Use tuple syntax instead."));
+    }
+    return serializeLiteralValue(value, opts);
+};
 
+var KNOWN_FUNCTION_LOOKUP = new Set(SQL_KNOWN_FUNCTIONS.map(function (name) { return String(name).toUpperCase(); }));
 var AggregateBuilder = /** @class */ (function (_super) {
     __extends(AggregateBuilder, _super);
     function AggregateBuilder() {
@@ -1817,112 +2293,71 @@ var AggregateBuilder = /** @class */ (function (_super) {
     AggregateBuilder.prototype.assertValidIdentifier = function (_identifier, _context) {
         // no-op placeholder for subclasses that do not implement alias validation
     };
-    AggregateBuilder.prototype.buildAggregateField = function (field, params) {
-        var _this = this;
-        var _a, _b;
-        if (typeof field === 'string') {
-            this.assertValidIdentifier(field, 'SELECT field');
-            return field;
-        }
-        if (!Array.isArray(field) || field.length === 0) {
-            throw new Error('Invalid SELECT field entry');
-        }
-        // If the array represents a tuple/literal list (e.g., [lng, lat]) rather than a
-        // function call like [FN, ...args], serialize the list as a comma-separated
-        // literal sequence so parent calls (like ORDER BY FN(<here>)) can embed it.
-        var isNumericString = function (s) { return /^-?\d+(?:\.\d+)?$/.test(String(s).trim()); };
-        if (typeof field[0] !== 'string' || isNumericString(field[0])) {
-            return field
-                .map(function (arg) {
-                if (Array.isArray(arg))
-                    return _this.buildAggregateField(arg, params);
-                return String(arg);
-            })
-                .join(', ');
-        }
-        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 isGeomFromText = F === C6C.ST_GEOMFROMTEXT.toUpperCase();
-        if (args.length === 1 && Array.isArray(args[0])) {
-            args = args[0];
-        }
-        // Parameter placeholder helper: [C6C.PARAM, value]
-        if (F === C6C.PARAM) {
-            if (!params) {
-                throw new Error('PARAM requires parameter tracking.');
-            }
-            var value = args[0];
-            // Use empty column context; ORDER/SELECT literals have no column typing.
-            // @ts-ignore addParam is provided by ConditionBuilder in our hierarchy.
-            return this.addParam(params, '', value);
-        }
-        if (F === C6C.SUBSELECT) {
-            if (!params) {
-                throw new Error('Scalar subselects in SELECT require parameter tracking.');
-            }
-            var subRequest = args[0];
-            var subSql = (_b = (_a = this).buildScalarSubSelect) === null || _b === void 0 ? void 0 : _b.call(_a, subRequest, params);
-            if (!subSql) {
-                throw new Error('Failed to build scalar subselect.');
-            }
-            var expr_1 = subSql;
-            if (alias) {
-                this.selectAliases.add(alias);
-                expr_1 += " AS ".concat(alias);
-            }
-            logWithLevel(LogLevel.DEBUG, getLogContext(this.config, this.request), console.log, "[SELECT] ".concat(expr_1));
-            return expr_1;
-        }
-        var identifierPathRegex = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
-        var argList = args
-            .map(function (arg, index) {
-            if (Array.isArray(arg))
-                return _this.buildAggregateField(arg, params);
-            if (typeof arg === 'string') {
-                if (identifierPathRegex.test(arg)) {
-                    _this.assertValidIdentifier(arg, 'SELECT expression');
-                    return arg;
-                }
-                // Treat numeric-looking strings as literals, not identifier paths
-                if (isNumericString(arg))
-                    return arg;
-                if (isGeomFromText && index === 0) {
-                    var trimmed = arg.trim();
-                    var alreadyQuoted = trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2;
-                    if (alreadyQuoted) {
-                        return trimmed;
-                    }
-                    var escaped = arg.replace(/'/g, "''");
-                    return "'".concat(escaped, "'");
-                }
-                return arg;
-            }
-            return String(arg);
-        })
-            .join(', ');
-        var expr;
-        if (F === 'DISTINCT') {
-            expr = "DISTINCT ".concat(argList);
+    AggregateBuilder.prototype.isReferenceExpression = function (value) {
+        if (typeof value !== 'string')
+            return false;
+        var trimmed = value.trim();
+        if (trimmed.length === 0)
+            return false;
+        if (trimmed === '*')
+            return true;
+        if (/^[A-Za-z_][A-Za-z0-9_]*\.\*$/.test(trimmed)) {
+            this.assertValidIdentifier(trimmed, 'SQL reference');
+            return true;
         }
-        else {
-            expr = "".concat(F, "(").concat(argList, ")");
+        if (/^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed)) {
+            this.assertValidIdentifier(trimmed, 'SQL reference');
+            return true;
         }
-        if (alias) {
-            this.selectAliases.add(alias);
-            expr += " AS ".concat(alias);
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed) && this.selectAliases.has(trimmed)) {
+            return true;
         }
-        logWithLevel(LogLevel.DEBUG, getLogContext(this.config, this.request), console.log, "[SELECT] ".concat(expr));
-        return expr;
+        return false;
+    };
+    AggregateBuilder.prototype.isKnownFunction = function (functionName) {
+        return KNOWN_FUNCTION_LOOKUP.has(functionName.trim().toUpperCase());
+    };
+    AggregateBuilder.prototype.serializeExpression = function (expression, params, context, contextColumn) {
+        var _this = this;
+        if (context === void 0) { context = 'SQL expression'; }
+        return serializeSqlExpression(expression, {
+            params: params,
+            context: context,
+            contextColumn: contextColumn,
+            hooks: {
+                assertValidIdentifier: function (identifier, hookContext) {
+                    _this.assertValidIdentifier(identifier, hookContext);
+                },
+                isReference: function (value) { return _this.isReferenceExpression(value); },
+                addParam: function (target, column, value) {
+                    var addParam = _this.addParam;
+                    if (typeof addParam !== 'function') {
+                        throw new Error('Expression literal binding requires addParam support.');
+                    }
+                    return addParam.call(_this, target, column, value);
+                },
+                buildScalarSubSelect: function (subRequest, target) {
+                    var builder = _this.buildScalarSubSelect;
+                    if (typeof builder !== 'function') {
+                        throw new Error('Scalar subselects require SelectQueryBuilder context.');
+                    }
+                    return builder.call(_this, subRequest, target);
+                },
+                onAlias: function (alias) {
+                    _this.selectAliases.add(alias);
+                },
+                isKnownFunction: function (functionName) { return _this.isKnownFunction(functionName); },
+            },
+        });
+    };
+    AggregateBuilder.prototype.buildAggregateField = function (field, params) {
+        var serialized = this.serializeExpression(field, params, 'SELECT expression');
+        logWithLevel(LogLevel.DEBUG, getLogContext(this.config, this.request), console.log, "[SELECT] ".concat(serialized.sql));
+        return serialized.sql;
     };
     return AggregateBuilder;
 }(Executor));
 
-// Alias a table name with a given alias
 var DERIVED_TABLE_PREFIX = '__c6DerivedTable__';
 var DERIVED_ID_SYMBOL = Symbol('c6DerivedTableId');
 var derivedTableLookup = new Map();
@@ -2000,6 +2435,29 @@ var bbox = function (minLng, minLat, maxLng, maxLat) {
 var stContains = function (envelope, shape) {
     return [C6C.ST_CONTAINS, envelope, shape];
 };
+// Strongly-typed known function helper.
+var fn = function (functionName) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return __spreadArray([functionName], args, true);
+};
+// Escape hatch for custom function names.
+var call = function (functionName) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return __spreadArray([C6C.CALL, functionName], args, true);
+};
+var alias = function (expression, aliasName) { return [C6C.AS, expression, aliasName]; };
+var distinct = function (expression) { return [C6C.DISTINCT, expression]; };
+var lit = function (value) { return [C6C.LIT, value]; };
+var order = function (expression, direction) {
+    if (direction === void 0) { direction = C6C.ASC; }
+    return [expression, direction];
+};
 
 var ConditionBuilder = /** @class */ (function (_super) {
     __extends(ConditionBuilder, _super);
@@ -2106,6 +2564,26 @@ var ConditionBuilder = /** @class */ (function (_super) {
             return true;
         return false;
     };
+    ConditionBuilder.prototype.isReferenceExpression = function (value) {
+        var trimmed = value.trim();
+        if (trimmed === '*') {
+            return true;
+        }
+        if (trimmed.includes('.')) {
+            if (/^[A-Za-z_][A-Za-z0-9_]*\.\*$/.test(trimmed)) {
+                return true;
+            }
+            if (this.isTableReference(trimmed) || this.isColumnRef(trimmed)) {
+                return true;
+            }
+            if (/^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed)) {
+                this.assertValidIdentifier(trimmed, 'SQL reference');
+                return true;
+            }
+            return false;
+        }
+        return _super.prototype.isReferenceExpression.call(this, trimmed);
+    };
     ConditionBuilder.prototype.execute = function () {
         throw new Error("Method not implemented.");
     };
@@ -2135,16 +2613,8 @@ var ConditionBuilder = /** @class */ (function (_super) {
             Object.values(table.COLUMNS).includes(column));
     };
     ConditionBuilder.prototype.addParam = function (params, column, value) {
-        var _a, _b, _c, _d, _e;
-        // Determine column definition from C6.TABLES to support type-aware conversions (e.g., BINARY hex -> Buffer)
-        var columnDef;
-        if (typeof column === 'string' && column.includes('.')) {
-            var _f = column.split('.', 2), tableName = _f[0], colName = _f[1];
-            var table = (_b = (_a = this.config.C6) === null || _a === void 0 ? void 0 : _a.TABLES) === null || _b === void 0 ? void 0 : _b[tableName];
-            // Support both short-keyed and fully-qualified TYPE_VALIDATION entries
-            columnDef = (_d = (_c = table === null || table === void 0 ? void 0 : table.TYPE_VALIDATION) === null || _c === void 0 ? void 0 : _c[colName]) !== null && _d !== void 0 ? _d : (_e = table === null || table === void 0 ? void 0 : table.TYPE_VALIDATION) === null || _e === void 0 ? void 0 : _e["".concat(tableName, ".").concat(colName)];
-        }
-        var val = convertHexIfBinary(column, value, columnDef);
+        var columnDef = this.resolveColumnDefinition(column);
+        var val = convertSqlValueForColumn(column, value, columnDef);
         if (this.useNamedParams) {
             var key = "param".concat(Object.keys(params).length);
             params[key] = val;
@@ -2180,41 +2650,6 @@ var ConditionBuilder = /** @class */ (function (_super) {
     ConditionBuilder.prototype.isOperator = function (op) {
         return !!this.normalizeOperatorKey(op);
     };
-    ConditionBuilder.prototype.looksLikeSafeFunctionExpression = function (value) {
-        if (typeof value !== 'string')
-            return false;
-        var trimmed = value.trim();
-        if (trimmed.length === 0)
-            return false;
-        if (trimmed.includes(';') || trimmed.includes('--') || trimmed.includes('/*') || trimmed.includes('*/')) {
-            return false;
-        }
-        if (!trimmed.includes('(') || !trimmed.endsWith(')')) {
-            return false;
-        }
-        var functionMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\s*\(/);
-        if (!functionMatch) {
-            return false;
-        }
-        var allowedCharacters = /^[A-Za-z0-9_().,'"\s-]+$/;
-        if (!allowedCharacters.test(trimmed)) {
-            return false;
-        }
-        var depth = 0;
-        for (var _i = 0, trimmed_1 = trimmed; _i < trimmed_1.length; _i++) {
-            var char = trimmed_1[_i];
-            if (char === '(') {
-                depth += 1;
-            }
-            else if (char === ')') {
-                depth -= 1;
-                if (depth < 0) {
-                    return false;
-                }
-            }
-        }
-        return depth === 0;
-    };
     ConditionBuilder.prototype.ensureWrapped = function (expression) {
         var trimmed = expression.trim();
         if (!trimmed)
@@ -2242,42 +2677,6 @@ var ConditionBuilder = /** @class */ (function (_super) {
         })
             .join(" ".concat(operator, " "));
     };
-    ConditionBuilder.prototype.normalizeFunctionField = function (field, params) {
-        var _this = this;
-        if (field instanceof Map) {
-            field = Object.fromEntries(field);
-        }
-        if (Array.isArray(field)) {
-            if (field.length === 0)
-                return field;
-            var fn = field[0], args = field.slice(1);
-            var normalizedArgs = args.map(function (arg) { return _this.normalizeFunctionField(arg, params); });
-            return __spreadArray([fn], normalizedArgs, true);
-        }
-        if (field && typeof field === 'object') {
-            if (C6C.SUBSELECT in field) {
-                var builder = this.buildScalarSubSelect;
-                if (typeof builder !== 'function') {
-                    throw new Error('Scalar subselect handling requires JoinBuilder context.');
-                }
-                return builder.call(this, field[C6C.SUBSELECT], params);
-            }
-            var entries = Object.entries(field);
-            if (entries.length === 1) {
-                var _a = entries[0], key = _a[0], value = _a[1];
-                if (this.isOperator(key)) {
-                    return this.buildOperatorExpression(key, value, params);
-                }
-                return this.buildFunctionCall(key, value, params);
-            }
-        }
-        return field;
-    };
-    ConditionBuilder.prototype.buildFunctionCall = function (fn, value, params) {
-        var args = Array.isArray(value) ? value : [value];
-        var normalized = this.normalizeFunctionField(__spreadArray([fn], args, true), params);
-        return this.buildAggregateField(normalized, params);
-    };
     ConditionBuilder.prototype.serializeOperand = function (operand, params, contextColumn) {
         var _a;
         var _this = this;
@@ -2292,18 +2691,14 @@ var ConditionBuilder = /** @class */ (function (_super) {
             return { sql: asParam(operand), isReference: false, isExpression: false, isSubSelect: false };
         }
         if (typeof operand === 'string') {
-            if (this.isTableReference(operand) || this.isColumnRef(operand)) {
-                return { sql: operand, isReference: true, isExpression: false, isSubSelect: false };
+            var trimmed = operand.trim();
+            if (this.isReferenceExpression(trimmed) || this.isTableReference(trimmed) || this.isColumnRef(trimmed)) {
+                return { sql: trimmed, isReference: true, isExpression: false, isSubSelect: false };
             }
-            if (this.looksLikeSafeFunctionExpression(operand)) {
-                return { sql: operand.trim(), isReference: false, isExpression: true, isSubSelect: false };
-            }
-            return { sql: asParam(operand), isReference: false, isExpression: false, isSubSelect: false };
+            throw new Error("Bare string '".concat(operand, "' is not a reference. Wrap literal strings with [C6C.LIT, value]."));
         }
         if (Array.isArray(operand)) {
-            var normalized = this.normalizeFunctionField(operand, params);
-            var sql = this.buildAggregateField(normalized, params);
-            return { sql: sql, isReference: false, isExpression: true, isSubSelect: false };
+            return this.serializeExpression(operand, params, 'SQL expression', contextColumn);
         }
         if (operand instanceof Map) {
             operand = Object.fromEntries(operand);
@@ -2321,24 +2716,38 @@ var ConditionBuilder = /** @class */ (function (_super) {
             if (entries.length === 1) {
                 var _b = entries[0], key = _b[0], value = _b[1];
                 if (this.isOperator(key)) {
-                    var sql_1 = this.buildOperatorExpression(key, value, params);
-                    return { sql: this.ensureWrapped(sql_1), isReference: false, isExpression: true, isSubSelect: false };
+                    var sql = this.buildOperatorExpression(key, value, params);
+                    return { sql: this.ensureWrapped(sql), isReference: false, isExpression: true, isSubSelect: false };
                 }
                 if (this.BOOLEAN_OPERATORS.has(key)) {
-                    var sql_2 = this.buildBooleanExpression((_a = {}, _a[key] = value, _a), params, 'AND');
-                    return { sql: this.ensureWrapped(sql_2), isReference: false, isExpression: true, isSubSelect: false };
+                    var sql = this.buildBooleanExpression((_a = {}, _a[key] = value, _a), params, 'AND');
+                    return { sql: this.ensureWrapped(sql), isReference: false, isExpression: true, isSubSelect: false };
                 }
-                var sql = this.buildFunctionCall(key, value, params);
-                return { sql: sql, isReference: false, isExpression: true, isSubSelect: false };
+                throw new Error('Object-rooted expressions are not supported. Use tuple syntax instead.');
             }
         }
         throw new Error('Unsupported operand type in SQL expression.');
     };
+    ConditionBuilder.prototype.isExpressionTuple = function (value) {
+        if (!Array.isArray(value) || value.length === 0 || typeof value[0] !== 'string') {
+            return false;
+        }
+        var token = String(value[0]).toUpperCase();
+        return (token === C6C.AS
+            || token === C6C.DISTINCT
+            || token === C6C.CALL
+            || token === C6C.LIT
+            || token === C6C.PARAM
+            || token === C6C.SUBSELECT
+            || this.isKnownFunction(value[0]));
+    };
     ConditionBuilder.prototype.isPlainArrayLiteral = function (value, allowColumnRefs) {
         var _this = this;
         if (allowColumnRefs === void 0) { allowColumnRefs = false; }
         if (!Array.isArray(value))
             return false;
+        if (this.isExpressionTuple(value))
+            return false;
         return value.every(function (item) {
             if (item === null)
                 return true;
@@ -2408,6 +2817,16 @@ var ConditionBuilder = /** @class */ (function (_super) {
             || this.isPlainObjectLiteral(normalized, allowColumnRefs)) {
             return this.addParam(params, contextColumn !== null && contextColumn !== void 0 ? contextColumn : '', JSON.stringify(normalized));
         }
+        if (normalized === C6C.NULL
+            || normalized === null
+            || typeof normalized === 'string'
+            || typeof normalized === 'number'
+            || typeof normalized === 'boolean'
+            || normalized instanceof Date
+            || (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(normalized))) {
+            var scalar = normalized === C6C.NULL ? null : normalized;
+            return this.addParam(params, contextColumn !== null && contextColumn !== void 0 ? contextColumn : '', scalar);
+        }
         var sql;
         var isReference;
         var isExpression;
@@ -2491,7 +2910,10 @@ var ConditionBuilder = /** @class */ (function (_super) {
         }
         var payload = this.ensurePlainObject(payloadRaw);
         var subSelect;
-        if (payload && typeof payload === 'object' && C6C.SUBSELECT in payload) {
+        if (Array.isArray(payload) && payload.length === 2 && String(payload[0]).toUpperCase() === C6C.SUBSELECT) {
+            subSelect = this.ensurePlainObject(payload[1]);
+        }
+        else if (payload && typeof payload === 'object' && C6C.SUBSELECT in payload) {
             subSelect = this.ensurePlainObject(payload[C6C.SUBSELECT]);
         }
         else if (payload && typeof payload === 'object') {
@@ -2585,7 +3007,11 @@ var ConditionBuilder = /** @class */ (function (_super) {
                 throw new Error('MATCH_AGAINST expects an array [search, mode?].');
             }
             var search = right[0], mode = right[1];
-            var placeholder = this.addParam(params, leftInfo_1.sql, search);
+            var searchInfo = this.serializeOperand(search, params, leftInfo_1.sql);
+            if (searchInfo.isReference || searchInfo.isExpression || searchInfo.isSubSelect) {
+                throw new Error('MATCH_AGAINST search payload must be a literal value (wrap strings with [C6C.LIT, value]).');
+            }
+            var placeholder = searchInfo.sql;
             var againstClause = void 0;
             switch (typeof mode === 'string' ? mode.toUpperCase() : '') {
                 case 'BOOLEAN':
@@ -2687,7 +3113,7 @@ var ConditionBuilder = /** @class */ (function (_super) {
                 if (!Array.isArray(value)) {
                     throw new Error("".concat(column, " expects an array of arguments."));
                 }
-                return this.buildFunctionCall(column, value, params);
+                return this.serializeExpression(__spreadArray([column], value, true), params, "WHERE function ".concat(column), column).sql;
             }
         }
         if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value)) {
@@ -3130,56 +3556,34 @@ var PaginationBuilder = /** @class */ (function (_super) {
      *
      * 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")]
-     * }
+     * ORDER: [
+     *   [property_units.UNIT_ID, "DESC"],
+     *   [[C6Constants.ST_DISTANCE_SPHERE, property_units.LOCATION, F(property_units.LOCATION, "pu_target")], "ASC"],
+     * ]
      * ```
      */
     PaginationBuilder.prototype.buildPaginationClause = function (pagination, params) {
-        var _this = this;
         var sql = "";
         /* -------- ORDER BY -------- */
         if (pagination === null || pagination === void 0 ? void 0 : pagination[C6Constants.ORDER]) {
             var orderParts = [];
-            var _loop_1 = function (key, val) {
-                if (typeof key === 'string' && key.includes('.')) {
-                    this_1.assertValidIdentifier(key, 'ORDER BY');
-                }
-                // FUNCTION CALL: val is an array of args
-                if (Array.isArray(val)) {
-                    var identifierPathRegex_1 = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
-                    var isNumericString_1 = function (s) { return /^-?\d+(?:\.\d+)?$/.test(s.trim()); };
-                    var args = val
-                        .map(function (arg) {
-                        if (Array.isArray(arg))
-                            return _this.buildAggregateField(arg, params);
-                        if (typeof arg === 'string') {
-                            if (identifierPathRegex_1.test(arg)) {
-                                _this.assertValidIdentifier(arg, 'ORDER BY argument');
-                                return arg;
-                            }
-                            // numeric-looking strings should be treated as literals
-                            if (isNumericString_1(arg))
-                                return arg;
-                            return arg;
-                        }
-                        return String(arg);
-                    })
-                        .join(", ");
-                    orderParts.push("".concat(key, "(").concat(args, ")"));
-                }
-                // SIMPLE COLUMN + DIR (ASC/DESC)
-                else {
-                    orderParts.push("".concat(key, " ").concat(String(val).toUpperCase()));
+            var orderSpec = pagination[C6Constants.ORDER];
+            if (!Array.isArray(orderSpec)) {
+                throw new Error('PAGINATION.ORDER expects an array of terms using [expression, direction?] syntax.');
+            }
+            for (var _i = 0, orderSpec_1 = orderSpec; _i < orderSpec_1.length; _i++) {
+                var rawTerm = orderSpec_1[_i];
+                var expression = rawTerm;
+                var direction = C6Constants.ASC;
+                if (Array.isArray(rawTerm)
+                    && rawTerm.length === 2
+                    && typeof rawTerm[1] === 'string'
+                    && (String(rawTerm[1]).toUpperCase() === C6Constants.ASC || String(rawTerm[1]).toUpperCase() === C6Constants.DESC)) {
+                    expression = rawTerm[0];
+                    direction = String(rawTerm[1]).toUpperCase();
                 }
-            };
-            var this_1 = this;
-            for (var _i = 0, _a = Object.entries(pagination[C6Constants.ORDER]); _i < _a.length; _i++) {
-                var _b = _a[_i], key = _b[0], val = _b[1];
-                _loop_1(key, val);
+                var serialized = this.serializeExpression(expression, params, 'ORDER BY expression');
+                orderParts.push("".concat(serialized.sql, " ").concat(direction));
             }
             if (orderParts.length)
                 sql += " ORDER BY ".concat(orderParts.join(", "));
@@ -3469,7 +3873,7 @@ function normalizeSingularRequest(requestMethod, request, restModel, removedPrim
         throw new Error("Singular request requires all primary key(s) [".concat(pkShorts.join(', '), "] for table (").concat(restModel.TABLE_NAME, "). Missing: [").concat(missing.join(', '), "]"));
     }
     // Strip API metadata that should remain at root
-    var _d = request, dataInsertMultipleRows = _d.dataInsertMultipleRows, cacheResults = _d.cacheResults, fetchDependencies = _d.fetchDependencies, debug = _d.debug, success = _d.success, error = _d.error, rest = __rest(_d, ["dataInsertMultipleRows", "cacheResults", "fetchDependencies", "debug", "success", "error"]);
+    var _d = request, dataInsertMultipleRows = _d.dataInsertMultipleRows, cacheResults = _d.cacheResults, skipReactBootstrap = _d.skipReactBootstrap, fetchDependencies = _d.fetchDependencies, debug = _d.debug, success = _d.success, error = _d.error, rest = __rest(_d, ["dataInsertMultipleRows", "cacheResults", "skipReactBootstrap", "fetchDependencies", "debug", "success", "error"]);
     // Map short primary keys to fully-qualified column names
     var shortToFull = {};
     for (var _e = 0, _f = Object.entries(restModel.COLUMNS || {}); _e < _f.length; _e++) {
@@ -3481,22 +3885,26 @@ function normalizeSingularRequest(requestMethod, request, restModel, removedPrim
         var k = _a[0], v = _a[1];
         return [(_b = shortToFull[k]) !== null && _b !== void 0 ? _b : k, v];
     }));
+    var pkWhereExpressions = Object.fromEntries(Object.entries(pkFullValues).map(function (_a) {
+        var column = _a[0], value = _a[1];
+        return [column, [C6Constants.EQUAL, [C6Constants.LIT, value]]];
+    }));
     if (requestMethod === C6Constants.GET) {
         var normalized_1 = {
-            WHERE: __assign({}, pkFullValues),
+            WHERE: __assign({}, pkWhereExpressions),
         };
         // Preserve pagination if any was added previously
         if (request[C6Constants.PAGINATION]) {
             normalized_1[C6Constants.PAGINATION] = request[C6Constants.PAGINATION];
         }
-        return __assign(__assign({}, normalized_1), { dataInsertMultipleRows: dataInsertMultipleRows, cacheResults: cacheResults, fetchDependencies: fetchDependencies, debug: debug, success: success, error: error });
+        return __assign(__assign({}, normalized_1), { dataInsertMultipleRows: dataInsertMultipleRows, cacheResults: cacheResults, skipReactBootstrap: skipReactBootstrap, fetchDependencies: fetchDependencies, debug: debug, success: success, error: error });
     }
     if (requestMethod === C6Constants.DELETE) {
         var normalized_2 = (_a = {},
             _a[C6Constants.DELETE] = true,
-            _a.WHERE = __assign({}, pkFullValues),
+            _a.WHERE = __assign({}, pkWhereExpressions),
             _a);
-        return __assign(__assign({}, normalized_2), { dataInsertMultipleRows: dataInsertMultipleRows, cacheResults: cacheResults, fetchDependencies: fetchDependencies, debug: debug, success: success, error: error });
+        return __assign(__assign({}, normalized_2), { dataInsertMultipleRows: dataInsertMultipleRows, cacheResults: cacheResults, skipReactBootstrap: skipReactBootstrap, fetchDependencies: fetchDependencies, debug: debug, success: success, error: error });
     }
     // PUT
     var updateBody = {};
@@ -3515,11 +3923,12 @@ function normalizeSingularRequest(requestMethod, request, restModel, removedPrim
     }
     var normalized = (_b = {},
         _b[C6Constants.UPDATE] = updateBody,
-        _b.WHERE = __assign({}, pkFullValues),
+        _b.WHERE = __assign({}, pkWhereExpressions),
         _b);
-    return __assign(__assign({}, normalized), { dataInsertMultipleRows: dataInsertMultipleRows, cacheResults: cacheResults, fetchDependencies: fetchDependencies, debug: debug, success: success, error: error });
+    return __assign(__assign({}, normalized), { dataInsertMultipleRows: dataInsertMultipleRows, cacheResults: cacheResults, skipReactBootstrap: skipReactBootstrap, fetchDependencies: fetchDependencies, debug: debug, success: success, error: error });
 }
 
+var DEFAULT_NORMALIZER_CACHE_KEY = "__default__";
 var allowListCache = new Map();
 var ANSI_ESCAPE_REGEX = /\x1b\[[0-9;]*m/g;
 var COLLAPSED_BIND_ROW_REGEX = /\(\?\s*×\d+\)/g;
@@ -3571,7 +3980,17 @@ var normalizeSql = function (sql) {
     normalized = normalized.replace(/;\s*$/, "");
     return normalized.replace(/\s+/g, " ").trim();
 };
-var parseAllowList = function (raw, sourcePath) {
+var normalizeSqlWith = function (sql, sqlQueryNormalizer) {
+    var normalized = normalizeSql(sql);
+    if (!sqlQueryNormalizer)
+        return normalized;
+    var customized = sqlQueryNormalizer(normalized);
+    if (typeof customized !== "string") {
+        throw new Error("sqlQueryNormalizer must return a string.");
+    }
+    return customized.replace(/\s+/g, " ").trim();
+};
+var parseAllowList = function (raw, sourcePath, sqlQueryNormalizer) {
     var parsed;
     try {
         parsed = JSON.parse(raw);
@@ -3584,59 +4003,63 @@ var parseAllowList = function (raw, sourcePath) {
     }
     var sqlEntries = parsed
         .filter(function (entry) { return typeof entry === "string"; })
-        .map(normalizeSql)
+        .map(function (entry) { return normalizeSqlWith(entry, sqlQueryNormalizer); })
         .filter(function (entry) { return entry.length > 0; });
     if (sqlEntries.length !== parsed.length) {
         throw new Error("SQL allowlist at ".concat(sourcePath, " must contain only string entries."));
     }
     return sqlEntries;
 };
-var loadSqlAllowList = function (allowListPath) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, readFile, stat, fileStat, cached, raw, sqlEntries, allowList;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
+var loadSqlAllowList = function (allowListPath, sqlQueryNormalizer) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, readFile, stat, fileStat, pathCache, cacheKey, cached, raw, sqlEntries, allowList;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
             case 0:
                 if (!isNode()) {
                     throw new Error("SQL allowlist validation requires a Node runtime.");
                 }
                 return [4 /*yield*/, import('node:fs/promises')];
             case 1:
-                _a = _b.sent(), readFile = _a.readFile, stat = _a.stat;
-                _b.label = 2;
+                _a = _c.sent(), readFile = _a.readFile, stat = _a.stat;
+                _c.label = 2;
             case 2:
-                _b.trys.push([2, 4, , 5]);
+                _c.trys.push([2, 4, , 5]);
                 return [4 /*yield*/, stat(allowListPath)];
             case 3:
-                fileStat = _b.sent();
+                fileStat = _c.sent();
                 return [3 /*break*/, 5];
             case 4:
-                _b.sent();
+                _c.sent();
                 throw new Error("SQL allowlist file not found at ".concat(allowListPath, "."));
             case 5:
-                cached = allowListCache.get(allowListPath);
+                pathCache = (_b = allowListCache.get(allowListPath)) !== null && _b !== void 0 ? _b : new Map();
+                cacheKey = sqlQueryNormalizer !== null && sqlQueryNormalizer !== void 0 ? sqlQueryNormalizer : DEFAULT_NORMALIZER_CACHE_KEY;
+                cached = pathCache.get(cacheKey);
                 if (cached &&
                     cached.mtimeMs === fileStat.mtimeMs &&
                     cached.size === fileStat.size) {
                     return [2 /*return*/, cached.allowList];
                 }
-                _b.label = 6;
+                _c.label = 6;
             case 6:
-                _b.trys.push([6, 8, , 9]);
+                _c.trys.push([6, 8, , 9]);
                 return [4 /*yield*/, readFile(allowListPath, "utf-8")];
             case 7:
-                raw = _b.sent();
+                raw = _c.sent();
                 return [3 /*break*/, 9];
             case 8:
-                _b.sent();
+                _c.sent();
                 throw new Error("SQL allowlist file not found at ".concat(allowListPath, "."));
             case 9:
-                sqlEntries = parseAllowList(raw, allowListPath);
+                sqlEntries = parseAllowList(raw, allowListPath, sqlQueryNormalizer);
                 allowList = new Set(sqlEntries);
-                allowListCache.set(allowListPath, {
+                pathCache.set(cacheKey, {
                     allowList: allowList,
                     mtimeMs: fileStat.mtimeMs,
                     size: fileStat.size,
                 });
+                allowListCache.set(allowListPath, pathCache);
                 return [2 /*return*/, allowList];
         }
     });
@@ -3663,15 +4086,15 @@ var extractSqlEntries = function (payload) {
     }
     return [];
 };
-var collectSqlAllowListEntries = function (payload, entries) {
+var collectSqlAllowListEntries = function (payload, entries, sqlQueryNormalizer) {
     if (entries === void 0) { entries = new Set(); }
     var sqlEntries = extractSqlEntries(payload)
-        .map(normalizeSql)
+        .map(function (entry) { return normalizeSqlWith(entry, sqlQueryNormalizer); })
         .filter(function (entry) { return entry.length > 0; });
     sqlEntries.forEach(function (entry) { return entries.add(entry); });
     return entries;
 };
-var compileSqlAllowList = function (allowListPath, entries) { return __awaiter(void 0, void 0, void 0, function () {
+var compileSqlAllowList = function (allowListPath, entries, sqlQueryNormalizer) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, writeFile, mkdir, path, compiled;
     return __generator(this, function (_b) {
         switch (_b.label) {
@@ -3689,7 +4112,7 @@ var compileSqlAllowList = function (allowListPath, entries) { return __awaiter(v
             case 3:
                 _b.sent();
                 compiled = Array.from(new Set(Array.from(entries)
-                    .map(normalizeSql)
+                    .map(function (entry) { return normalizeSqlWith(entry, sqlQueryNormalizer); })
                     .filter(function (entry) { return entry.length > 0; }))).sort();
                 return [4 /*yield*/, writeFile(allowListPath, JSON.stringify(compiled, null, 2))];
             case 4:
@@ -4065,6 +4488,7 @@ var SqlExecutor = /** @class */ (function (_super) {
             C6Constants.REPLACE,
             "dataInsertMultipleRows",
             "cacheResults",
+            "skipReactBootstrap",
             "fetchDependencies",
             "debug",
             "success",
@@ -4148,9 +4572,10 @@ var SqlExecutor = /** @class */ (function (_super) {
                 }
             }
             if (value !== undefined) {
-                pkValues[pkShort] = value;
+                pkValues[pkShort] = this_1.unwrapPrimaryKeyValue(value);
             }
         };
+        var this_1 = this;
         for (var _i = 0, primaryShorts_1 = primaryShorts; _i < primaryShorts_1.length; _i++) {
             var pkShort = primaryShorts_1[_i];
             _loop_1(pkShort);
@@ -4160,6 +4585,26 @@ var SqlExecutor = /** @class */ (function (_super) {
         }
         return Object.keys(pkValues).length > 0 ? pkValues : null;
     };
+    SqlExecutor.prototype.unwrapPrimaryKeyValue = function (value) {
+        if (!Array.isArray(value))
+            return value;
+        if (value.length === 2) {
+            var head = value[0], tail = value[1];
+            if (head === C6Constants.EQUAL) {
+                return this.unwrapPrimaryKeyValue(tail);
+            }
+            if (head === C6Constants.LIT || head === C6Constants.PARAM) {
+                return tail;
+            }
+        }
+        if (value.length === 3) {
+            var operator = value[1], right = value[2];
+            if (operator === C6Constants.EQUAL) {
+                return this.unwrapPrimaryKeyValue(right);
+            }
+        }
+        return value;
+    };
     SqlExecutor.prototype.extractPrimaryKeyValuesFromData = function (data) {
         if (!data)
             return null;
@@ -4520,7 +4965,7 @@ var SqlExecutor = /** @class */ (function (_super) {
     };
     SqlExecutor.prototype.validateSqlAllowList = function (sql) {
         return __awaiter(this, void 0, void 0, function () {
-            var allowListPath, allowList, normalized;
+            var allowListPath, sqlQueryNormalizer, allowList, normalized;
             var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -4529,10 +4974,11 @@ var SqlExecutor = /** @class */ (function (_super) {
                         if (!allowListPath) {
                             return [2 /*return*/, "not verified"];
                         }
-                        return [4 /*yield*/, loadSqlAllowList(allowListPath)];
+                        sqlQueryNormalizer = this.config.sqlQueryNormalizer;
+                        return [4 /*yield*/, loadSqlAllowList(allowListPath, sqlQueryNormalizer)];
                     case 1:
                         allowList = _b.sent();
-                        normalized = normalizeSql(sql);
+                        normalized = normalizeSqlWith(sql, sqlQueryNormalizer);
                         if (!allowList.has(normalized)) {
                             throw createSqlAllowListBlockedError({
                                 tableName: typeof ((_a = this.config.restModel) === null || _a === void 0 ? void 0 : _a.TABLE_NAME) === "string"
@@ -4780,5 +5226,5 @@ function isVerbose() {
     return resolveLogLevel() >= LogLevel.DEBUG;
 }
 
-export { A, AggregateBuilder, C6C, C6Constants, ConditionBuilder, DELETE, DeleteQueryBuilder, Executor, ExpressHandler, F, GET, HttpExecutor, JoinBuilder, LogLevel, POST, PUT, PaginationBuilder, PostQueryBuilder, SelectQueryBuilder, SqlExecutor, TestRestfulResponse, UpdateQueryBuilder, apiRequestCache, applyLogLevelDefaults, axiosInstance, bbox, carbonNodeQsStringify, checkAllRequestsComplete, checkCache, clearCache, collectSqlAllowListEntries, colorSql, compileSqlAllowList, convertForRequestBody, convertHexIfBinary, derivedTable, determineRuntimeJsType, distSphere, eFetchDependencies, error, evictCacheEntry, extractSqlEntries, fieldEq, getEnv, getEnvBool, getEnvDebug, getEnvLogLevel, getLogContext, getPrimaryKeyTypes, group, info, isDerivedTableKey, isLocal, isNode, isTest, isVerbose, loadSqlAllowList, logSql, logWithLevel, normalizeSingularRequest, normalizeSql, notifyToast, onError, onSuccess, parseLogLevel, removeInvalidKeys, removePrefixIfExists, resolveDerivedTable, resolveLogLevel, restExpressRequest, restOrm, restRequest, setCache, setToastHandler, shouldLog, sortAndSerializeQueryObject, stContains, timeout, toastOptions, toastOptionsDevs, userCustomClearCache, versionToRgb as versionColor, warn };
+export { A, AggregateBuilder, C6C, C6Constants, ConditionBuilder, DELETE, DeleteQueryBuilder, Executor, ExpressHandler, F, GET, HttpExecutor, JoinBuilder, LogLevel, POST, PUT, PaginationBuilder, PostQueryBuilder, SQL_KNOWN_FUNCTIONS, SelectQueryBuilder, SqlExecutor, TestRestfulResponse, UpdateQueryBuilder, alias, apiRequestCache, applyLogLevelDefaults, axiosInstance, bbox, call, carbonNodeQsStringify, checkAllRequestsComplete, checkCache, clearCache, collectSqlAllowListEntries, colorSql, compileSqlAllowList, convertForRequestBody, convertHexIfBinary, convertSqlValueForColumn, derivedTable, determineRuntimeJsType, distSphere, distinct, eFetchDependencies, error, evictCacheEntry, extractSqlEntries, fieldEq, fn, getEnv, getEnvBool, getEnvDebug, getEnvLogLevel, getLogContext, getPrimaryKeyTypes, group, info, isDerivedTableKey, isLocal, isNode, isTest, isVerbose, lit, loadSqlAllowList, logSql, logWithLevel, normalizeSingularRequest, normalizeSql, normalizeSqlWith, notifyToast, onError, onSuccess, order, parseLogLevel, removeInvalidKeys, removePrefixIfExists, resolveDerivedTable, resolveLogLevel, restExpressRequest, restOrm, restRequest, serializeSqlExpression, setCache, setToastHandler, shouldLog, sortAndSerializeQueryObject, stContains, timeout, toastOptions, toastOptionsDevs, userCustomClearCache, versionToRgb as versionColor, warn };
 //# sourceMappingURL=index.esm.js.map