@carbonorm/carbonnode 3.11.0 → 4.0.0

package/dist/index.esm.js

@@ -304,8 +304,30 @@ axiosInstance.interceptors.request.use(function (config) {
             };
         }
     }
+    config.__carbonStart = performance.now();
     return config;
 });
+axiosInstance.interceptors.response.use(function (response) {
+    var end = performance.now();
+    var start = response.config.__carbonStart;
+    response.__carbonTiming = {
+        start: start,
+        end: end,
+        duration: end - start,
+    };
+    return response;
+}, function (error) {
+    if (error.config) {
+        var end = performance.now();
+        var start = error.config.__carbonStart;
+        error.__carbonTiming = {
+            start: start,
+            end: end,
+            duration: end - start,
+        };
+    }
+    throw error;
+});
 
 function convertForRequestBody (restfulObject, tableName, C6, regexErrorHandler) {
     if (regexErrorHandler === void 0) { regexErrorHandler = alert; }
@@ -407,10 +429,7 @@ function convertForRequestBody (restfulObject, tableName, C6, regexErrorHandler)
 
 var isNode = function () {
     var _a;
-    console.log('Checking if running in Node.js environment...');
-    var isNodeEnv = typeof process !== 'undefined' && !!((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
-    console.log("Is Node.js environment: ".concat(isNodeEnv));
-    return isNodeEnv;
+    return typeof process !== 'undefined' && !!((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
 };
 
 /**
@@ -628,26 +647,64 @@ function removeInvalidKeys(request, c6Tables) {
     return intersection;
 }
 
-// do not remove entries from this array. It is used to track the progress of API requests.
-// position in array is important. Do not sort. To not add to begging.
-var apiRequestCache = [];
+// -----------------------------------------------------------------------------
+// Cache Storage
+// -----------------------------------------------------------------------------
+var apiRequestCache = new Map();
 var userCustomClearCache = [];
+// -----------------------------------------------------------------------------
+// Cache Key Generator (safe, fixed-size ~40 chars)
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// Browser-safe deterministic hash (FNV-1a)
+// -----------------------------------------------------------------------------
+function fnv1a(str) {
+    var h = 0x811c9dc5;
+    for (var i = 0; i < str.length; i++) {
+        h ^= str.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
+    }
+    return h.toString(16);
+}
+function makeCacheKey(method, tableName, requestData) {
+    var raw = JSON.stringify([method, tableName, requestData]);
+    return fnv1a(raw);
+}
+// -----------------------------------------------------------------------------
+// Clear Cache (no shared-array bugs)
+// -----------------------------------------------------------------------------
 function clearCache(props) {
-    if (false === (props === null || props === void 0 ? void 0 : props.ignoreWarning)) {
-        console.warn('The rest api clearCache should only be used with extreme care! Avoid using this in favor of using `cacheResults : boolean`.');
+    if (!(props === null || props === void 0 ? void 0 : props.ignoreWarning)) {
+        console.warn("The REST API clearCache should only be used with extreme care!");
+    }
+    for (var _i = 0, userCustomClearCache_1 = userCustomClearCache; _i < userCustomClearCache_1.length; _i++) {
+        var fn = userCustomClearCache_1[_i];
+        try {
+            fn();
+        }
+        catch (_a) { }
     }
-    userCustomClearCache.map(function (f) { return 'function' === typeof f && f(); });
-    userCustomClearCache = apiRequestCache = [];
+    apiRequestCache.clear();
 }
-function checkCache(cacheResult, requestMethod, tableName, request) {
-    if (undefined === cacheResult) {
+// -----------------------------------------------------------------------------
+// Check Cache (dedupe via hashed key)
+// -----------------------------------------------------------------------------
+function checkCache(method, tableName, requestData) {
+    var key = makeCacheKey(method, tableName, requestData);
+    var cached = apiRequestCache.get(key);
+    if (!cached)
         return false;
-    }
-    console.groupCollapsed('%c API: The request on (' + tableName + ') is in cache. Returning the request Promise!', 'color: #0c0');
-    console.log('%c ' + requestMethod + ' ' + tableName, 'color: #0c0');
-    console.log('%c Request Data (note you may see the success and/or error prompt):', 'color: #0c0', request);
+    console.groupCollapsed("%c API cache hit for ".concat(method, " ").concat(tableName), "color:#0c0");
+    console.log("Request Data:", requestData);
     console.groupEnd();
-    return cacheResult.request;
+    return cached.request;
+}
+// -----------------------------------------------------------------------------
+// Store Cache Entry (drop-in compatible)
+// -----------------------------------------------------------------------------
+function setCache(method, tableName, requestData, cacheEntry) {
+    var key = makeCacheKey(method, tableName, requestData);
+    apiRequestCache.set(key, cacheEntry);
 }
 
 function sortAndSerializeQueryObject(tables, query) {
@@ -664,7 +721,10 @@ var HttpExecutor = /** @class */ (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     HttpExecutor.prototype.isRestResponse = function (r) {
-        return !!r && r.data != null && typeof r.data === 'object' && 'rest' in r.data;
+        return !!r
+            && r.data != null
+            && typeof r.data === 'object'
+            && Array.isArray(r.data.rest);
     };
     HttpExecutor.prototype.stripTableNameFromKeys = function (obj) {
         var _a;
@@ -767,19 +827,9 @@ var HttpExecutor = /** @class */ (function (_super) {
                             console.log('request', this.request);
                             console.groupEnd();
                         }
-                        // an undefined query would indicate queryCallback returned undefined,
-                        // thus the request shouldn't fire as is in custom cache
-                        if (undefined === this.request || null === this.request) {
-                            if (isLocal()) {
-                                console.groupCollapsed("API: (".concat(requestMethod, ") (").concat(tableName, ") query undefined/null \u2192 returning null"));
-                                console.log('request', this.request);
-                                console.groupEnd();
-                            }
-                            return [2 /*return*/, null];
-                        }
                         query = this.request;
                         apiRequest = function () { return __awaiter(_this, void 0, void 0, function () {
-                            var _a, debug, _b, cacheResults, dataInsertMultipleRows, success, _c, fetchDependencies, _d, error, querySerialized, cacheResult, cachingConfirmed, cacheCheck, cacheCheck, apiResponse, returnGetNextPageFunction, restRequestUri, needsConditionOrPrimaryCheck, TABLES, primaryKeyList, primaryKeyFullyQualified, primaryKey, whereVal, whereIsEmpty, providedPrimary, primaryVal, axiosActiveRequest;
+                            var _a, debug, _b, cacheResults, dataInsertMultipleRows, success, _c, fetchDependencies, _d, error, cachingConfirmed, cacheRequestData, querySerialized, cachedRequest, apiResponse, restRequestUri, needsConditionOrPrimaryCheck, TABLES, primaryKeyList, primaryKeyFullyQualified, primaryKey, whereVal, whereIsEmpty, providedPrimary, primaryVal, axiosActiveRequest_1;
                             var _e;
                             var _this = this;
                             var _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
@@ -795,63 +845,37 @@ var HttpExecutor = /** @class */ (function (_super) {
                                             console.log('request', this.request);
                                             console.groupEnd();
                                         }
-                                        querySerialized = sortAndSerializeQueryObject(tables, query !== null && query !== void 0 ? query : {});
-                                        cacheResult = apiRequestCache.find(function (cache) { return cache.requestArgumentsSerialized === querySerialized; });
                                         cachingConfirmed = false;
-                                        if (!(requestMethod === C6.GET)) return [3 /*break*/, 9];
-                                        if (undefined === (query === null || query === void 0 ? void 0 : query[C6.PAGINATION])) {
-                                            if (undefined === query || null === query) {
-                                                query = {};
+                                        // determine if we need to paginate.
+                                        if (requestMethod === C6.GET) {
+                                            if (undefined === (query === null || query === void 0 ? void 0 : query[C6.PAGINATION])) {
+                                                if (undefined === query || null === query) {
+                                                    query = {};
+                                                }
+                                                query[C6.PAGINATION] = {};
                                             }
-                                            query[C6.PAGINATION] = {};
+                                            query[C6.PAGINATION][C6.PAGE] = query[C6.PAGINATION][C6.PAGE] || 1;
+                                            query[C6.PAGINATION][C6.LIMIT] = query[C6.PAGINATION][C6.LIMIT] || 100;
+                                        }
+                                        cacheRequestData = JSON.parse(JSON.stringify(query !== null && query !== void 0 ? query : {}));
+                                        querySerialized = sortAndSerializeQueryObject(tables, cacheRequestData !== null && cacheRequestData !== void 0 ? cacheRequestData : {});
+                                        cachedRequest = false;
+                                        if (cacheResults) {
+                                            cachedRequest = checkCache(requestMethod, tableName, cacheRequestData);
                                         }
-                                        query[C6.PAGINATION][C6.PAGE] = query[C6.PAGINATION][C6.PAGE] || 1;
-                                        query[C6.PAGINATION][C6.LIMIT] = query[C6.PAGINATION][C6.LIMIT] || 100;
-                                        if (!(true === cacheResults)) return [3 /*break*/, 7];
-                                        if (!(undefined !== cacheResult)) return [3 /*break*/, 6];
-                                        _r.label = 1;
-                                    case 1:
-                                        cacheCheck = checkCache(cacheResult, requestMethod, tableName, this.request);
-                                        if (!(false !== cacheCheck)) return [3 /*break*/, 3];
-                                        return [4 /*yield*/, cacheCheck];
-                                    case 2: return [2 /*return*/, (_r.sent()).data];
-                                    case 3:
-                                        ++query[C6.PAGINATION][C6.PAGE];
-                                        querySerialized = sortAndSerializeQueryObject(tables, query !== null && query !== void 0 ? query : {});
-                                        cacheResult = apiRequestCache.find(function (cache) { return cache.requestArgumentsSerialized === querySerialized; });
-                                        _r.label = 4;
-                                    case 4:
-                                        if (undefined !== cacheResult) return [3 /*break*/, 1];
-                                        _r.label = 5;
-                                    case 5:
-                                        if (debug && isLocal()) {
-                                            toast.warning("DEVS: Request pages exhausted in cache; firing network.", toastOptionsDevs);
+                                        if (!cachedRequest) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, cachedRequest];
+                                    case 1: return [2 /*return*/, (_r.sent()).data];
+                                    case 2:
+                                        if (cacheResults) {
+                                            cachingConfirmed = true;
                                         }
-                                        _r.label = 6;
-                                    case 6:
-                                        cachingConfirmed = true;
-                                        return [3 /*break*/, 8];
-                                    case 7:
-                                        if (debug && isLocal())
+                                        else if (debug && isLocal()) {
                                             toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
-                                        _r.label = 8;
-                                    case 8:
-                                        if (debug && isLocal()) {
+                                        }
+                                        if (cacheResults && debug && isLocal()) {
                                             toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? " Page (" + query[C6.PAGINATION][C6.PAGE] + ")" : ''), toastOptionsDevs);
                                         }
-                                        return [3 /*break*/, 12];
-                                    case 9:
-                                        if (!cacheResults) return [3 /*break*/, 12];
-                                        if (!cacheResult) return [3 /*break*/, 11];
-                                        cacheCheck = checkCache(cacheResult, requestMethod, tableName, this.request);
-                                        if (!(false !== cacheCheck)) return [3 /*break*/, 11];
-                                        return [4 /*yield*/, cacheCheck];
-                                    case 10: return [2 /*return*/, (_r.sent()).data];
-                                    case 11:
-                                        cachingConfirmed = true;
-                                        _r.label = 12;
-                                    case 12:
-                                        returnGetNextPageFunction = false;
                                         restRequestUri = restURL + operatingTable + '/';
                                         needsConditionOrPrimaryCheck = (PUT === requestMethod || DELETE === requestMethod)
                                             && false === skipPrimaryCheck;
@@ -921,7 +945,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                 config: this.config,
                                                 request: this.request
                                             });
-                                            axiosActiveRequest = (_e = axios)[requestMethod.toLowerCase()].apply(_e, __spreadArray([restRequestUri], (function () {
+                                            axiosActiveRequest_1 = (_e = axios)[requestMethod.toLowerCase()].apply(_e, __spreadArray([restRequestUri], (function () {
                                                 var convert = function (data) {
                                                     return convertForRequestBody(data, fullTableList, C6, function (message) { return toast.error(message, toastOptions); });
                                                 };
@@ -948,23 +972,30 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                 }
                                             })(), false));
                                             if (cachingConfirmed) {
-                                                // push to cache so we do not repeat the request
-                                                apiRequestCache.push({
+                                                setCache(requestMethod, tableName, cacheRequestData, {
                                                     requestArgumentsSerialized: querySerialized,
-                                                    request: axiosActiveRequest
+                                                    request: axiosActiveRequest_1,
                                                 });
                                             }
                                             // returning the promise with this then is important for tests. todo - we could make that optional.
                                             // https://rapidapi.com/guides/axios-async-await
-                                            return [2 /*return*/, axiosActiveRequest.then(function (response) { return __awaiter(_this, void 0, void 0, function () {
-                                                    var cacheIndex, callback, responseData_1, pageLimit, got, hasNext, cacheIndex, dependencies_1, fetchReferences_1, apiRequestPromises, _loop_1, tableToFetch;
+                                            return [2 /*return*/, axiosActiveRequest_1.then(function (response) { return __awaiter(_this, void 0, void 0, function () {
+                                                    var hasNext, callback, responseData_1, pageLimit, got, dependencies_1, fetchReferences_1, apiRequestPromises, _loop_1, tableToFetch;
                                                     var _this = this;
-                                                    var _a, _b, _c, _d;
-                                                    return __generator(this, function (_e) {
-                                                        switch (_e.label) {
+                                                    var _a, _b, _c, _d, _e;
+                                                    return __generator(this, function (_f) {
+                                                        switch (_f.label) {
                                                             case 0:
                                                                 // noinspection SuspiciousTypeOfGuard
                                                                 if (typeof response.data === 'string') {
+                                                                    if (cachingConfirmed) {
+                                                                        setCache(requestMethod, tableName, cacheRequestData, {
+                                                                            requestArgumentsSerialized: querySerialized,
+                                                                            request: axiosActiveRequest_1,
+                                                                            response: response,
+                                                                            final: true,
+                                                                        });
+                                                                    }
                                                                     if (isTest()) {
                                                                         console.trace();
                                                                         throw new Error('The response data was a string this typically indicated html was sent. Make sure all cookies (' + JSON.stringify(response.config.headers) + ') needed are present! (' + response.data + ')');
@@ -972,11 +1003,11 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                     return [2 /*return*/, Promise.reject(response)];
                                                                 }
                                                                 if (cachingConfirmed) {
-                                                                    cacheIndex = apiRequestCache.findIndex(function (cache) { return cache.requestArgumentsSerialized === querySerialized; });
-                                                                    // TODO - currently nonthing is setting this correctly
-                                                                    apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction;
-                                                                    // only cache get method requests
-                                                                    apiRequestCache[cacheIndex].response = response;
+                                                                    setCache(requestMethod, tableName, cacheRequestData, {
+                                                                        requestArgumentsSerialized: querySerialized,
+                                                                        request: axiosActiveRequest_1,
+                                                                        response: response,
+                                                                    });
                                                                 }
                                                                 this.runLifecycleHooks("afterExecution", {
                                                                     config: this.config,
@@ -1027,17 +1058,18 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                 got = responseData_1.rest.length;
                                                                 hasNext = pageLimit !== 1 && got === pageLimit;
                                                                 if (hasNext) {
-                                                                    responseData_1.next = apiRequest; // there might be more
+                                                                    responseData_1.next = apiRequest;
                                                                 }
                                                                 else {
                                                                     responseData_1.next = undefined; // short page => done
                                                                 }
-                                                                // If you keep this flag, make it reflect reality:
-                                                                returnGetNextPageFunction = hasNext;
-                                                                // and fix cache ‘final’ flag to match:
                                                                 if (cachingConfirmed) {
-                                                                    cacheIndex = apiRequestCache.findIndex(function (c) { return c.requestArgumentsSerialized === querySerialized; });
-                                                                    apiRequestCache[cacheIndex].final = !hasNext;
+                                                                    setCache(requestMethod, tableName, cacheRequestData, {
+                                                                        requestArgumentsSerialized: querySerialized,
+                                                                        request: axiosActiveRequest_1,
+                                                                        response: response,
+                                                                        final: !hasNext,
+                                                                    });
                                                                 }
                                                                 if ((this.config.verbose || debug) && isLocal()) {
                                                                     console.groupCollapsed("API: Response (".concat(requestMethod, " ").concat(tableName, ") len (").concat((_b = responseData_1.rest) === null || _b === void 0 ? void 0 : _b.length, ") of (").concat((_c = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _c === void 0 ? void 0 : _c[C6.LIMIT], ")"));
@@ -1047,7 +1079,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                 }
                                                                 if (!(fetchDependencies
                                                                     && 'number' === typeof fetchDependencies
-                                                                    && responseData_1.rest.length > 0)) return [3 /*break*/, 2];
+                                                                    && ((_d = responseData_1.rest) === null || _d === void 0 ? void 0 : _d.length) > 0)) return [3 /*break*/, 2];
                                                                 console.groupCollapsed('%c API: Fetch Dependencies segment (' + requestMethod + ' ' + tableName + ')'
                                                                     + (fetchDependencies & eFetchDependencies.CHILDREN ? ' | (CHILDREN|REFERENCED) ' : '')
                                                                     + (fetchDependencies & eFetchDependencies.PARENTS ? ' | (PARENTS|REFERENCED_BY)' : '')
@@ -1118,7 +1150,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                 }); });
                                                                 console.log('fetchReferences', fetchReferences_1);
                                                                 _loop_1 = function (tableToFetch) {
-                                                                    var _f;
+                                                                    var _g;
                                                                     if (fetchDependencies & eFetchDependencies.C6ENTITY
                                                                         && 'string' === typeof tableName
                                                                         && tableName.endsWith("carbon_carbons")) {
@@ -1141,7 +1173,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                         .split('_')
                                                                         .map(function (part) { return part.charAt(0).toUpperCase() + part.slice(1); })
                                                                         .join('_');
-                                                                    var RestApi = (_d = C6.ORM[ormKey]) !== null && _d !== void 0 ? _d : new Error("Fetch Dependencies could not find table (".concat(ormKey, ") in the set \u2209 [ ").concat(Object.keys(C6.ORM).join(', '), " ]"));
+                                                                    var RestApi = (_e = C6.ORM[ormKey]) !== null && _e !== void 0 ? _e : new Error("Fetch Dependencies could not find table (".concat(ormKey, ") in the set \u2209 [ ").concat(Object.keys(C6.ORM).join(', '), " ]"));
                                                                     console.log('%c Fetch Dependencies will select (' + tableToFetch + ') using GET request', 'color: #33ccff');
                                                                     var nextFetchDependencies = eFetchDependencies.NONE;
                                                                     if (fetchDependencies & eFetchDependencies.RECURSIVE) {
@@ -1167,8 +1199,8 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                     console.log('RestApi object', RestApi);
                                                                     // this is a dynamic call to the rest api, any generated table may resolve with (RestApi)
                                                                     // todo - using value to avoid joins.... but. maybe this should be a parameterizable option -- think race conditions; its safer to join
-                                                                    apiRequestPromises.push(RestApi.Get((_f = {},
-                                                                        _f[C6.WHERE] = Object.keys(fetchReferences_1[tableToFetch]).reduce(function (sum, column) {
+                                                                    apiRequestPromises.push(RestApi.Get((_g = {},
+                                                                        _g[C6.WHERE] = Object.keys(fetchReferences_1[tableToFetch]).reduce(function (sum, column) {
                                                                             fetchReferences_1[tableToFetch][column] = fetchReferences_1[tableToFetch][column].flat(Infinity);
                                                                             if (0 === fetchReferences_1[tableToFetch][column].length) {
                                                                                 console.warn('The column (' + column + ') was not found in the response data. We will not fetch.', responseData_1);
@@ -1181,8 +1213,8 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                                 ];
                                                                             return sum;
                                                                         }, {}),
-                                                                        _f.fetchDependencies = nextFetchDependencies,
-                                                                        _f)));
+                                                                        _g.fetchDependencies = nextFetchDependencies,
+                                                                        _g)));
                                                                 };
                                                                 for (tableToFetch in fetchReferences_1) {
                                                                     _loop_1(tableToFetch);
@@ -1190,7 +1222,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                 console.groupEnd();
                                                                 return [4 /*yield*/, Promise.all(apiRequestPromises)];
                                                             case 1:
-                                                                _e.sent();
+                                                                _f.sent();
                                                                 apiRequestPromises.map(function (promise) { return __awaiter(_this, void 0, void 0, function () {
                                                                     var _a, _b;
                                                                     return __generator(this, function (_c) {
@@ -1208,8 +1240,16 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                         }
                                                                     });
                                                                 }); });
-                                                                _e.label = 2;
+                                                                _f.label = 2;
                                                             case 2:
+                                                                if (cachingConfirmed && hasNext === undefined) {
+                                                                    setCache(requestMethod, tableName, cacheRequestData, {
+                                                                        requestArgumentsSerialized: querySerialized,
+                                                                        request: axiosActiveRequest_1,
+                                                                        response: response,
+                                                                        final: true,
+                                                                    });
+                                                                }
                                                                 if (debug && isLocal()) {
                                                                     toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
                                                                 }
@@ -1220,16 +1260,12 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                 }); }).then(function (response) { return response.data; })]; // this escapes from axios context
                                         }
                                         catch (throwableError) {
-                                            if (isTest()) {
-                                                throw new Error(JSON.stringify(throwableError));
-                                            }
                                             console.groupCollapsed('%c API: An error occurred in the try catch block. returning null!', 'color: #ff0000');
                                             console.log('%c ' + requestMethod + ' ' + tableName, 'color: #A020F0');
-                                            console.warn(throwableError);
+                                            console.error(throwableError);
                                             console.trace();
                                             console.groupEnd();
-                                            TestRestfulResponse(throwableError, success, error);
-                                            return [2 /*return*/, null];
+                                            throw new Error(JSON.stringify(throwableError));
                                         }
                                         return [2 /*return*/];
                                 }
@@ -1788,6 +1824,62 @@ var ConditionBuilder = /** @class */ (function (_super) {
         }
         throw new Error('Unsupported operand type in SQL expression.');
     };
+    ConditionBuilder.prototype.isPlainArrayLiteral = function (value) {
+        var _this = this;
+        if (!Array.isArray(value))
+            return false;
+        return value.every(function (item) {
+            if (item === null)
+                return true;
+            var type = typeof item;
+            if (type === 'string' || type === 'number' || type === 'boolean')
+                return true;
+            if (Array.isArray(item))
+                return _this.isPlainArrayLiteral(item);
+            if (item && typeof item === 'object')
+                return _this.isPlainObjectLiteral(item);
+            return false;
+        });
+    };
+    ConditionBuilder.prototype.isPlainObjectLiteral = function (value) {
+        var _this = this;
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return false;
+        if (value instanceof Date)
+            return false;
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value))
+            return false;
+        var normalized = value instanceof Map ? Object.fromEntries(value) : value;
+        if (C6C.SUBSELECT in normalized)
+            return false;
+        var entries = Object.entries(normalized);
+        if (entries.length === 0)
+            return true;
+        if (entries.some(function (_a) {
+            var key = _a[0];
+            return _this.isOperator(key) || _this.BOOLEAN_OPERATORS.has(key);
+        })) {
+            return false;
+        }
+        if (entries.some(function (_a) {
+            var key = _a[0];
+            return typeof key === 'string' && (_this.isColumnRef(key) || key.includes('.'));
+        })) {
+            return false;
+        }
+        return true;
+    };
+    ConditionBuilder.prototype.serializeUpdateValue = function (value, params, contextColumn) {
+        var normalized = value instanceof Map ? Object.fromEntries(value) : value;
+        if (this.isPlainArrayLiteral(normalized) || this.isPlainObjectLiteral(normalized)) {
+            return this.addParam(params, contextColumn !== null && contextColumn !== void 0 ? contextColumn : '', JSON.stringify(normalized));
+        }
+        var _a = this.serializeOperand(normalized, params, contextColumn), sql = _a.sql, isReference = _a.isReference, isExpression = _a.isExpression, isSubSelect = _a.isSubSelect;
+        if (!isReference && !isExpression && !isSubSelect && typeof normalized === 'object' && normalized !== null) {
+            throw new Error('Unsupported operand type in SQL expression.');
+        }
+        return sql;
+    };
     ConditionBuilder.prototype.ensurePlainObject = function (value) {
         if (value instanceof Map) {
             return Object.fromEntries(value);
@@ -2644,12 +2736,14 @@ var PostQueryBuilder = /** @class */ (function (_super) {
         var verb = C6C.REPLACE in this.request ? C6C.REPLACE : C6C.INSERT;
         var body = verb in this.request ? this.request[verb] : this.request;
         var keys = Object.keys(body);
-        var params = [];
+        var params = this.useNamedParams ? {} : [];
         var placeholders = [];
         for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
             var key = keys_1[_i];
             var value = body[key];
-            var placeholder = this.addParam(params, key, value);
+            var trimmed = this.trimTablePrefix(table, key);
+            var qualified = "".concat(table, ".").concat(trimmed);
+            var placeholder = this.serializeUpdateValue(value, params, qualified);
             placeholders.push(placeholder);
         }
         var sql = "".concat(verb, " INTO `").concat(table, "` (\n            ").concat(keys.map(function (k) { return "`".concat(_this.trimTablePrefix(table, k), "`"); }).join(', '), "\n         ) VALUES (\n            ").concat(placeholders.join(', '), "\n        )");
@@ -2701,7 +2795,9 @@ var UpdateQueryBuilder = /** @class */ (function (_super) {
             var col = _a[0], val = _a[1];
             var trimmed = _this.trimTablePrefix(table, col);
             var qualified = "".concat(table, ".").concat(trimmed);
-            return "`".concat(trimmed, "` = ").concat(_this.addParam(params, qualified, val));
+            _this.assertValidIdentifier(qualified, 'UPDATE SET');
+            var rightSql = _this.serializeUpdateValue(val, params, qualified);
+            return "`".concat(trimmed, "` = ").concat(rightSql);
         });
         sql += " SET ".concat(setClauses.join(', '));
         if (args.WHERE) {
@@ -3029,12 +3125,12 @@ function ExpressHandler(_a) {
     var _this = this;
     var C6 = _a.C6, mysqlPool = _a.mysqlPool;
     return function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
-        var incomingMethod, table, primary, methodOverrideRaw, methodOverride, treatAsGet, method, payload, primaryKeys, primaryKeyName, response, err_1;
-        var _a, _b, _c, _d, _e;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
+        var incomingMethod, table, primary, methodOverrideRaw, methodOverride, treatAsGet, method, payload, restModel, primaryKeys_1, primaryShortKeys_1, columnMap_1, resolveShortKey_1, hasPrimaryKeyValues, primaryKeyName, response, err_1;
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
                 case 0:
-                    _f.trys.push([0, 2, , 3]);
+                    _h.trys.push([0, 2, , 3]);
                     incomingMethod = req.method.toUpperCase();
                     table = req.params.table;
                     primary = req.params.primary;
@@ -3048,7 +3144,7 @@ function ExpressHandler(_a) {
                         try {
                             delete payload.METHOD;
                         }
-                        catch ( /* noop */_g) { /* noop */ }
+                        catch ( /* noop */_j) { /* noop */ }
                     }
                     // Warn for unsupported overrides but continue normally
                     if (incomingMethod !== 'GET' && methodOverride && methodOverride !== 'GET') {
@@ -3058,29 +3154,56 @@ function ExpressHandler(_a) {
                         res.status(400).json({ error: "Invalid table: ".concat(table) });
                         return [2 /*return*/];
                     }
-                    primaryKeys = C6.TABLES[table].PRIMARY;
-                    if (primary && primaryKeys.length !== 1) {
-                        if (primaryKeys.length > 1) {
+                    restModel = C6.TABLES[table];
+                    primaryKeys_1 = restModel.PRIMARY;
+                    primaryShortKeys_1 = (_d = restModel.PRIMARY_SHORT) !== null && _d !== void 0 ? _d : [];
+                    columnMap_1 = (_e = restModel.COLUMNS) !== null && _e !== void 0 ? _e : {};
+                    resolveShortKey_1 = function (fullKey, index) { var _a, _b, _c; return (_c = (_b = (_a = columnMap_1[fullKey]) !== null && _a !== void 0 ? _a : primaryShortKeys_1[index]) !== null && _b !== void 0 ? _b : fullKey.split('.').pop()) !== null && _c !== void 0 ? _c : fullKey; };
+                    hasPrimaryKeyValues = function (data) {
+                        if (!data || typeof data !== 'object')
+                            return false;
+                        var whereClause = data[C6C.WHERE];
+                        var hasKeyValue = function (obj, fullKey, shortKey) {
+                            if (!obj || typeof obj !== 'object')
+                                return false;
+                            var fullValue = obj[fullKey];
+                            if (fullValue !== undefined && fullValue !== null)
+                                return true;
+                            var shortValue = shortKey ? obj[shortKey] : undefined;
+                            return shortValue !== undefined && shortValue !== null;
+                        };
+                        return primaryKeys_1.every(function (fullKey, index) {
+                            var shortKey = resolveShortKey_1(fullKey, index);
+                            return hasKeyValue(whereClause, fullKey, shortKey) || hasKeyValue(data, fullKey, shortKey);
+                        });
+                    };
+                    if (primary && primaryKeys_1.length !== 1) {
+                        if (primaryKeys_1.length > 1 && hasPrimaryKeyValues(payload)) {
+                            primary = undefined;
+                        }
+                        else if (primaryKeys_1.length > 1) {
                             res.status(400).json({ error: "Table ".concat(table, " has multiple primary keys. Cannot implicitly determine key.") });
                             return [2 /*return*/];
                         }
-                        res.status(400).json({
-                            error: "Table ".concat(table, " has no primary keys. Please specify one.")
-                        });
-                        return [2 /*return*/];
+                        else {
+                            res.status(400).json({
+                                error: "Table ".concat(table, " has no primary keys. Please specify one.")
+                            });
+                            return [2 /*return*/];
+                        }
                     }
-                    primaryKeyName = primaryKeys[0];
+                    primaryKeyName = primaryKeys_1[0];
                     // If a primary key was provided in the URL, merge it into the payload.
                     // Support both complex requests using WHERE and singular requests
                     // where the primary key lives at the root of the payload.
                     if (primary) {
                         if (payload[C6C.WHERE]) {
                             payload[C6C.WHERE][primaryKeyName] =
-                                (_d = payload[C6C.WHERE][primaryKeyName]) !== null && _d !== void 0 ? _d : primary;
+                                (_f = payload[C6C.WHERE][primaryKeyName]) !== null && _f !== void 0 ? _f : primary;
                         }
                         else {
                             payload[primaryKeyName] =
-                                (_e = payload[primaryKeyName]) !== null && _e !== void 0 ? _e : primary;
+                                (_g = payload[primaryKeyName]) !== null && _g !== void 0 ? _g : primary;
                         }
                     }
                     return [4 /*yield*/, restRequest({
@@ -3090,11 +3213,11 @@ function ExpressHandler(_a) {
                             restModel: C6.TABLES[table]
                         })(payload)];
                 case 1:
-                    response = _f.sent();
+                    response = _h.sent();
                     res.status(200).json(__assign({ success: true }, response));
                     return [3 /*break*/, 3];
                 case 2:
-                    err_1 = _f.sent();
+                    err_1 = _h.sent();
                     res.status(500).json({ success: false, error: err_1 });
                     next(err_1);
                     return [3 /*break*/, 3];
@@ -3179,10 +3302,11 @@ function error(message) {
 }
 
 function checkAllRequestsComplete() {
-    var stillRunning = apiRequestCache.filter(function (cache) { return undefined === cache.response; });
+    var cacheEntries = Array.from(apiRequestCache.values());
+    var stillRunning = cacheEntries.filter(function (cache) { return undefined === cache.response; });
     if (stillRunning.length !== 0) {
         if (document === null || document === undefined) {
-            throw new Error('document is undefined while waiting for API requests to complete (' + JSON.stringify(apiRequestCache) + ')');
+            throw new Error('document is undefined while waiting for API requests to complete (' + JSON.stringify(cacheEntries) + ')');
         }
         // when requests return emtpy sets in full renders, it may not be possible to track their progress.
         console.warn('stillRunning...', stillRunning);
@@ -3203,5 +3327,5 @@ function isVerbose () {
     return ['true', '1', 'yes', 'on'].includes(envVerbose.toLowerCase());
 }
 
-export { A, AggregateBuilder, C6C, C6Constants, ConditionBuilder, DELETE, DeleteQueryBuilder, Executor, ExpressHandler, F, GET, HttpExecutor, JoinBuilder, POST, PUT, PaginationBuilder, PostQueryBuilder, SelectQueryBuilder, SqlExecutor, TestRestfulResponse, UpdateQueryBuilder, apiRequestCache, axiosInstance, bbox, carbonNodeQsStringify, checkAllRequestsComplete, checkCache, clearCache, convertForRequestBody, convertHexIfBinary, derivedTable, determineRuntimeJsType, distSphere, eFetchDependencies, error, fieldEq, getEnvVar, getPrimaryKeyTypes, group, info, isDerivedTableKey, isLocal, isNode, isTest, isVerbose, normalizeSingularRequest, onError, onSuccess, removeInvalidKeys, removePrefixIfExists, resolveDerivedTable, restOrm, restRequest, sortAndSerializeQueryObject, stContains, timeout, toastOptions, toastOptionsDevs, userCustomClearCache, warn };
+export { A, AggregateBuilder, C6C, C6Constants, ConditionBuilder, DELETE, DeleteQueryBuilder, Executor, ExpressHandler, F, GET, HttpExecutor, JoinBuilder, POST, PUT, PaginationBuilder, PostQueryBuilder, SelectQueryBuilder, SqlExecutor, TestRestfulResponse, UpdateQueryBuilder, apiRequestCache, axiosInstance, bbox, carbonNodeQsStringify, checkAllRequestsComplete, checkCache, clearCache, convertForRequestBody, convertHexIfBinary, derivedTable, determineRuntimeJsType, distSphere, eFetchDependencies, error, fieldEq, getEnvVar, getPrimaryKeyTypes, group, info, isDerivedTableKey, isLocal, isNode, isTest, isVerbose, normalizeSingularRequest, onError, onSuccess, removeInvalidKeys, removePrefixIfExists, resolveDerivedTable, restOrm, restRequest, setCache, sortAndSerializeQueryObject, stContains, timeout, toastOptions, toastOptionsDevs, userCustomClearCache, warn };
 //# sourceMappingURL=index.esm.js.map