@carbonorm/carbonnode 3.10.0 → 4.0.0

package/dist/index.cjs.js

@@ -38,10 +38,12 @@ var C6Constants = {
     DATE_FORMAT: 'DATE_FORMAT',
     DESC: 'DESC',
     DISTINCT: 'DISTINCT',
+    EXISTS: 'EXISTS',
     EXTRACT: 'EXTRACT',
     EQUAL: '=',
     EQUAL_NULL_SAFE: '<=>',
     FALSE: 'FALSE',
+    FORCE: 'FORCE',
     FULL_OUTER: 'FULL_OUTER',
     FROM_DAYS: 'FROM_DAYS',
     FROM_UNIXTIME: 'FROM_UNIXTIME',
@@ -57,6 +59,7 @@ var C6Constants = {
     HOUR_SECOND: 'HOUR_SECOND',
     HOUR_MINUTE: 'HOUR_MINUTE',
     IN: 'IN',
+    INDEX: 'INDEX',
     IS: 'IS',
     IS_NOT: 'IS_NOT',
     INNER: 'INNER',
@@ -74,6 +77,7 @@ var C6Constants = {
     MAKEDATE: 'MAKEDATE',
     MAKETIME: 'MAKETIME',
     MATCH_AGAINST: 'MATCH_AGAINST',
+    MBRCONTAINS: 'MBRContains',
     MONTHNAME: 'MONTHNAME',
     MICROSECOND: 'MICROSECOND',
     MINUTE: 'MINUTE',
@@ -89,8 +93,14 @@ var C6Constants = {
     NULL: 'NULL',
     ORDER: 'ORDER',
     OR: 'OR',
+    INDEX_HINTS: 'INDEX_HINTS',
+    FORCE_INDEX: 'FORCE INDEX',
+    USE_INDEX: 'USE INDEX',
+    IGNORE_INDEX: 'IGNORE INDEX',
     PAGE: 'PAGE',
     PAGINATION: 'PAGINATION',
+    POLYGON: 'POLYGON',
+    POINT: 'POINT',
     RIGHT_OUTER: 'RIGHT_OUTER',
     SECOND: 'SECOND',
     SECOND_MICROSECOND: 'SECOND_MICROSECOND',
@@ -297,8 +307,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; }
@@ -400,10 +432,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);
 };
 
 /**
@@ -621,26 +650,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.
-exports.apiRequestCache = [];
-exports.userCustomClearCache = [];
+// -----------------------------------------------------------------------------
+// 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) { }
     }
-    exports.userCustomClearCache.map(function (f) { return 'function' === typeof f && f(); });
-    exports.userCustomClearCache = exports.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) {
@@ -657,7 +724,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;
@@ -753,26 +823,16 @@ var HttpExecutor = /** @class */ (function (_super) {
                                 throw Error('Bad request method passed to getApi');
                         }
                         if (clearCache != null) {
-                            exports.userCustomClearCache.push(clearCache);
+                            userCustomClearCache.push(clearCache);
                         }
                         if (isLocal() && (this.config.verbose || ((_b = this.request) === null || _b === void 0 ? void 0 : _b.debug))) {
                             console.groupCollapsed('%c API:', 'color: #0c0', "(".concat(requestMethod, ") Request for (").concat(tableName, ")"));
                             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 tslib.__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;
@@ -788,63 +848,37 @@ var HttpExecutor = /** @class */ (function (_super) {
                                             console.log('request', this.request);
                                             console.groupEnd();
                                         }
-                                        querySerialized = sortAndSerializeQueryObject(tables, query !== null && query !== void 0 ? query : {});
-                                        cacheResult = exports.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 = exports.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()) {
-                                            reactToastify.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()) {
                                             reactToastify.toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
-                                        _r.label = 8;
-                                    case 8:
-                                        if (debug && isLocal()) {
+                                        }
+                                        if (cacheResults && debug && isLocal()) {
                                             reactToastify.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;
@@ -914,7 +948,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                 config: this.config,
                                                 request: this.request
                                             });
-                                            axiosActiveRequest = (_e = axios)[requestMethod.toLowerCase()].apply(_e, tslib.__spreadArray([restRequestUri], (function () {
+                                            axiosActiveRequest_1 = (_e = axios)[requestMethod.toLowerCase()].apply(_e, tslib.__spreadArray([restRequestUri], (function () {
                                                 var convert = function (data) {
                                                     return convertForRequestBody(data, fullTableList, C6, function (message) { return reactToastify.toast.error(message, toastOptions); });
                                                 };
@@ -941,23 +975,30 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                 }
                                             })(), false));
                                             if (cachingConfirmed) {
-                                                // push to cache so we do not repeat the request
-                                                exports.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 tslib.__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 tslib.__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 tslib.__generator(this, function (_e) {
-                                                        switch (_e.label) {
+                                                    var _a, _b, _c, _d, _e;
+                                                    return tslib.__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 + ')');
@@ -965,11 +1006,11 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                     return [2 /*return*/, Promise.reject(response)];
                                                                 }
                                                                 if (cachingConfirmed) {
-                                                                    cacheIndex = exports.apiRequestCache.findIndex(function (cache) { return cache.requestArgumentsSerialized === querySerialized; });
-                                                                    // TODO - currently nonthing is setting this correctly
-                                                                    exports.apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction;
-                                                                    // only cache get method requests
-                                                                    exports.apiRequestCache[cacheIndex].response = response;
+                                                                    setCache(requestMethod, tableName, cacheRequestData, {
+                                                                        requestArgumentsSerialized: querySerialized,
+                                                                        request: axiosActiveRequest_1,
+                                                                        response: response,
+                                                                    });
                                                                 }
                                                                 this.runLifecycleHooks("afterExecution", {
                                                                     config: this.config,
@@ -1020,17 +1061,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 = exports.apiRequestCache.findIndex(function (c) { return c.requestArgumentsSerialized === querySerialized; });
-                                                                    exports.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], ")"));
@@ -1040,7 +1082,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 & exports.eFetchDependencies.CHILDREN ? ' | (CHILDREN|REFERENCED) ' : '')
                                                                     + (fetchDependencies & exports.eFetchDependencies.PARENTS ? ' | (PARENTS|REFERENCED_BY)' : '')
@@ -1111,7 +1153,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                 }); });
                                                                 console.log('fetchReferences', fetchReferences_1);
                                                                 _loop_1 = function (tableToFetch) {
-                                                                    var _f;
+                                                                    var _g;
                                                                     if (fetchDependencies & exports.eFetchDependencies.C6ENTITY
                                                                         && 'string' === typeof tableName
                                                                         && tableName.endsWith("carbon_carbons")) {
@@ -1134,7 +1176,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 = exports.eFetchDependencies.NONE;
                                                                     if (fetchDependencies & exports.eFetchDependencies.RECURSIVE) {
@@ -1160,8 +1202,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);
@@ -1174,8 +1216,8 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                                                 ];
                                                                             return sum;
                                                                         }, {}),
-                                                                        _f.fetchDependencies = nextFetchDependencies,
-                                                                        _f)));
+                                                                        _g.fetchDependencies = nextFetchDependencies,
+                                                                        _g)));
                                                                 };
                                                                 for (tableToFetch in fetchReferences_1) {
                                                                     _loop_1(tableToFetch);
@@ -1183,7 +1225,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 tslib.__awaiter(_this, void 0, void 0, function () {
                                                                     var _a, _b;
                                                                     return tslib.__generator(this, function (_c) {
@@ -1201,8 +1243,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()) {
                                                                     reactToastify.toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
                                                                 }
@@ -1213,16 +1263,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*/];
                                 }
@@ -1451,7 +1497,8 @@ var stContains = function (envelope, shape) {
 var ConditionBuilder = /** @class */ (function (_super) {
     tslib.__extends(ConditionBuilder, _super);
     function ConditionBuilder() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _this = _super.apply(this, arguments) || this;
         _this.aliasMap = {};
         _this.derivedAliases = new Set();
         _this.BOOLEAN_OPERATORS = new Map([
@@ -1490,8 +1537,16 @@ var ConditionBuilder = /** @class */ (function (_super) {
             [C6C.BETWEEN, C6C.BETWEEN],
             ['BETWEEN', C6C.BETWEEN],
             ['NOT BETWEEN', 'NOT BETWEEN'],
+            [C6C.EXISTS, C6C.EXISTS],
+            ['EXISTS', C6C.EXISTS],
+            ['NOT EXISTS', 'NOT EXISTS'],
             [C6C.MATCH_AGAINST, C6C.MATCH_AGAINST],
         ]);
+        _this.BOOLEAN_FUNCTION_KEYS = new Set([
+            (_c = (_b = (_a = C6C.ST_CONTAINS) === null || _a === void 0 ? void 0 : _a.toUpperCase) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : 'ST_CONTAINS',
+            (_f = (_e = (_d = C6C.ST_WITHIN) === null || _d === void 0 ? void 0 : _d.toUpperCase) === null || _e === void 0 ? void 0 : _e.call(_d)) !== null && _f !== void 0 ? _f : 'ST_WITHIN',
+            (_j = (_h = (_g = C6C.MBRCONTAINS) === null || _g === void 0 ? void 0 : _g.toUpperCase) === null || _h === void 0 ? void 0 : _h.call(_g)) !== null && _j !== void 0 ? _j : 'MBRCONTAINS',
+        ]);
         return _this;
     }
     ConditionBuilder.prototype.initAlias = function (baseTable, joins) {
@@ -1726,6 +1781,9 @@ var ConditionBuilder = /** @class */ (function (_super) {
         if (operand === null || typeof operand === 'number' || typeof operand === 'boolean') {
             return { sql: asParam(operand), isReference: false, isExpression: false, isSubSelect: false };
         }
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(operand)) {
+            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 };
@@ -1769,10 +1827,185 @@ 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);
+        }
+        return value;
+    };
+    ConditionBuilder.prototype.resolveExistsInnerColumn = function (subRequest, provided) {
+        var _a, _b;
+        if (provided) {
+            if (typeof provided !== 'string' || provided.trim() === '') {
+                throw new Error('EXISTS correlation column must be a non-empty string.');
+            }
+            return provided;
+        }
+        var selectClause = this.ensurePlainObject(subRequest === null || subRequest === void 0 ? void 0 : subRequest[C6C.SELECT]);
+        if (Array.isArray(selectClause) && selectClause.length > 0) {
+            var candidate = selectClause[0];
+            if (typeof candidate === 'string' && candidate.trim() !== '') {
+                return candidate;
+            }
+        }
+        var fromTable = subRequest === null || subRequest === void 0 ? void 0 : subRequest[C6C.FROM];
+        if (typeof fromTable === 'string' && fromTable.trim() !== '') {
+            var table = (_b = (_a = this.config.C6) === null || _a === void 0 ? void 0 : _a.TABLES) === null || _b === void 0 ? void 0 : _b[fromTable.trim()];
+            var primary = table === null || table === void 0 ? void 0 : table.PRIMARY;
+            if (Array.isArray(primary) && primary.length > 0) {
+                return String(primary[0]);
+            }
+        }
+        throw new Error('EXISTS requires a correlation column to be provided or inferable from the subselect.');
+    };
+    ConditionBuilder.prototype.normalizeExistsSpec = function (spec) {
+        var normalized = this.ensurePlainObject(spec);
+        if (!Array.isArray(normalized) || normalized.length < 2) {
+            throw new Error('EXISTS expects an array like [outerColumn, subselect, innerColumn?].');
+        }
+        var outerRaw = normalized[0], payloadRaw = normalized[1], innerRaw = normalized[2];
+        if (typeof outerRaw !== 'string' || outerRaw.trim() === '') {
+            throw new Error('EXISTS requires the first element to be an outer column reference string.');
+        }
+        var payload = this.ensurePlainObject(payloadRaw);
+        var subSelect;
+        if (payload && typeof payload === 'object' && C6C.SUBSELECT in payload) {
+            subSelect = this.ensurePlainObject(payload[C6C.SUBSELECT]);
+        }
+        else if (payload && typeof payload === 'object') {
+            subSelect = payload;
+        }
+        else {
+            throw new Error('EXISTS requires a subselect payload as the second element.');
+        }
+        if (!subSelect || typeof subSelect !== 'object') {
+            throw new Error('EXISTS subselect payload must be an object.');
+        }
+        var innerColumn = typeof innerRaw === 'string' ? innerRaw : undefined;
+        return {
+            outerColumn: outerRaw,
+            subRequest: tslib.__assign({}, subSelect),
+            innerColumn: innerColumn,
+        };
+    };
+    ConditionBuilder.prototype.buildExistsExpression = function (spec, operator, params) {
+        var _a, _b, _c, _d;
+        var _this = this;
+        var _e;
+        var _f = this.normalizeExistsSpec(spec), outerColumn = _f.outerColumn, subRequest = _f.subRequest, innerColumn = _f.innerColumn;
+        var fromTableRaw = subRequest[C6C.FROM];
+        if (typeof fromTableRaw !== 'string' || fromTableRaw.trim() === '') {
+            throw new Error('EXISTS subselect requires a table specified with C6C.FROM.');
+        }
+        var fromTable = fromTableRaw.trim();
+        this.assertValidIdentifier(outerColumn, 'EXISTS correlation column');
+        var correlationColumn = this.resolveExistsInnerColumn(subRequest, innerColumn);
+        if (!this.isColumnRef(correlationColumn) && !this.isTableReference(correlationColumn)) {
+            throw new Error("Unknown column reference '".concat(correlationColumn, "' used in EXISTS subquery correlation column."));
+        }
+        var existingWhereRaw = this.ensurePlainObject(subRequest[C6C.WHERE]);
+        var correlationCondition = (_a = {}, _a[correlationColumn] = [C6C.EQUAL, outerColumn], _a);
+        var normalizedExistingWhere = existingWhereRaw && typeof existingWhereRaw === 'object'
+            ? Array.isArray(existingWhereRaw)
+                ? existingWhereRaw.slice()
+                : tslib.__assign({}, existingWhereRaw)
+            : existingWhereRaw;
+        var hasExistingWhere = Array.isArray(normalizedExistingWhere)
+            ? normalizedExistingWhere.length > 0
+            : normalizedExistingWhere && typeof normalizedExistingWhere === 'object'
+                ? Object.keys(normalizedExistingWhere).length > 0
+                : normalizedExistingWhere != null;
+        var whereClause;
+        if (!hasExistingWhere) {
+            whereClause = correlationCondition;
+        }
+        else if (normalizedExistingWhere && typeof normalizedExistingWhere === 'object' &&
+            Object.keys(normalizedExistingWhere).some(function (key) { return _this.BOOLEAN_OPERATORS.has(key); })) {
+            whereClause = (_b = {}, _b[C6C.AND] = [normalizedExistingWhere, correlationCondition], _b);
+        }
+        else if (normalizedExistingWhere && typeof normalizedExistingWhere === 'object') {
+            whereClause = tslib.__assign(tslib.__assign({}, normalizedExistingWhere), correlationCondition);
+        }
+        else {
+            whereClause = (_c = {}, _c[C6C.AND] = [normalizedExistingWhere, correlationCondition], _c);
+        }
+        var subRequestWithCorrelation = tslib.__assign(tslib.__assign({}, subRequest), (_d = {}, _d[C6C.FROM] = fromTable, _d[C6C.WHERE] = whereClause, _d[C6C.SELECT] = (_e = subRequest[C6C.SELECT]) !== null && _e !== void 0 ? _e : ['1'], _d));
+        var buildScalarSubSelect = this.buildScalarSubSelect;
+        if (typeof buildScalarSubSelect !== 'function') {
+            throw new Error('EXISTS operator requires SelectQueryBuilder context.');
+        }
+        var scalar = buildScalarSubSelect.call(this, subRequestWithCorrelation, params);
+        var keyword = operator === 'NOT EXISTS' ? 'NOT EXISTS' : C6C.EXISTS;
+        return "".concat(keyword, " ").concat(scalar);
+    };
     ConditionBuilder.prototype.buildOperatorExpression = function (op, rawOperands, params, contextColumn) {
         var _a, _b;
         var _this = this;
         var operator = this.formatOperator(op);
+        if (operator === C6C.EXISTS || operator === 'NOT EXISTS') {
+            var operands_1 = Array.isArray(rawOperands) ? rawOperands : [rawOperands];
+            if (!operands_1.length) {
+                throw new Error("".concat(operator, " requires at least one subselect specification."));
+            }
+            var clauses = operands_1.map(function (spec) { return _this.buildExistsExpression(spec, operator, params); });
+            return this.joinBooleanParts(clauses, 'AND');
+        }
         if (operator === C6C.MATCH_AGAINST) {
             if (!Array.isArray(rawOperands) || rawOperands.length !== 2) {
                 throw new Error('MATCH_AGAINST requires an array of two operands.');
@@ -1882,6 +2115,18 @@ var ConditionBuilder = /** @class */ (function (_super) {
         if (value instanceof Map) {
             value = Object.fromEntries(value);
         }
+        if (typeof column === 'string') {
+            var normalizedColumn = column.trim().toUpperCase();
+            if (this.BOOLEAN_FUNCTION_KEYS.has(normalizedColumn)) {
+                if (!Array.isArray(value)) {
+                    throw new Error("".concat(column, " expects an array of arguments."));
+                }
+                return this.buildFunctionCall(column, value, params);
+            }
+        }
+        if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(value)) {
+            return this.buildOperatorExpression(C6C.EQUAL, [column, value], params, column);
+        }
         if (Array.isArray(value)) {
             if (value.length >= 2 && typeof value[0] === 'string') {
                 var op = value[0], rest = value.slice(1);
@@ -2054,6 +2299,143 @@ var JoinBuilder = /** @class */ (function (_super) {
     JoinBuilder.prototype.createSelectBuilder = function (_request) {
         throw new Error('Subclasses must implement createSelectBuilder to support derived table serialization.');
     };
+    JoinBuilder.prototype.resetIndexHints = function () {
+        this.indexHintCache = undefined;
+    };
+    JoinBuilder.prototype.normalizeIndexHintKey = function (key) {
+        return key
+            .replace(/`/g, '')
+            .replace(/_/g, ' ')
+            .trim()
+            .replace(/\s+/g, ' ')
+            .toUpperCase();
+    };
+    JoinBuilder.prototype.normalizeHintTargetKey = function (target) {
+        return target.replace(/`/g, '').trim();
+    };
+    JoinBuilder.prototype.hasIndexHintKeys = function (obj) {
+        var _this = this;
+        var keys = Object.keys(obj !== null && obj !== void 0 ? obj : {});
+        if (!keys.length)
+            return false;
+        var forceKey = this.normalizeIndexHintKey(C6C.FORCE_INDEX);
+        var useKey = this.normalizeIndexHintKey(C6C.USE_INDEX);
+        var ignoreKey = this.normalizeIndexHintKey(C6C.IGNORE_INDEX);
+        return keys.some(function (key) {
+            var normalized = _this.normalizeIndexHintKey(key);
+            return normalized === forceKey || normalized === useKey || normalized === ignoreKey;
+        });
+    };
+    JoinBuilder.prototype.normalizeHintSpec = function (spec) {
+        var _a;
+        if (spec instanceof Map) {
+            spec = Object.fromEntries(spec);
+        }
+        if (Array.isArray(spec) || typeof spec === 'string') {
+            return _a = {}, _a[C6C.FORCE_INDEX] = spec, _a;
+        }
+        if (!spec || typeof spec !== 'object') {
+            return undefined;
+        }
+        if (!this.hasIndexHintKeys(spec)) {
+            return undefined;
+        }
+        return spec;
+    };
+    JoinBuilder.prototype.formatIndexHintClause = function (spec) {
+        var normalizedSpec = this.normalizeHintSpec(spec);
+        if (!normalizedSpec)
+            return '';
+        var clauses = [];
+        var forceKey = this.normalizeIndexHintKey(C6C.FORCE_INDEX);
+        var useKey = this.normalizeIndexHintKey(C6C.USE_INDEX);
+        var ignoreKey = this.normalizeIndexHintKey(C6C.IGNORE_INDEX);
+        var pushClause = function (keyword, rawValue) {
+            var values = Array.isArray(rawValue) ? rawValue : [rawValue];
+            var indexes = values
+                .map(function (value) { return String(value !== null && value !== void 0 ? value : '').trim(); })
+                .filter(Boolean)
+                .map(function (value) { return "`".concat(value.replace(/`/g, '``'), "`"); });
+            if (!indexes.length)
+                return;
+            clauses.push("".concat(keyword, " (").concat(indexes.join(', '), ")"));
+        };
+        for (var _i = 0, _a = Object.entries(normalizedSpec); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], rawValue = _b[1];
+            var normalizedKey = this.normalizeIndexHintKey(key);
+            if (normalizedKey === forceKey) {
+                pushClause('FORCE INDEX', rawValue);
+            }
+            else if (normalizedKey === useKey) {
+                pushClause('USE INDEX', rawValue);
+            }
+            else if (normalizedKey === ignoreKey) {
+                pushClause('IGNORE INDEX', rawValue);
+            }
+        }
+        return clauses.join(' ');
+    };
+    JoinBuilder.prototype.normalizeIndexHints = function (raw) {
+        var _this = this;
+        if (raw instanceof Map) {
+            raw = Object.fromEntries(raw);
+        }
+        var cache = new Map();
+        var addEntry = function (target, spec) {
+            var clause = _this.formatIndexHintClause(spec);
+            if (!clause)
+                return;
+            var normalizedTarget = target === '__base__'
+                ? '__base__'
+                : _this.normalizeHintTargetKey(target);
+            cache.set(normalizedTarget, clause);
+        };
+        if (Array.isArray(raw) || typeof raw === 'string') {
+            addEntry('__base__', raw);
+        }
+        else if (raw && typeof raw === 'object') {
+            if (this.hasIndexHintKeys(raw)) {
+                addEntry('__base__', raw);
+            }
+            else {
+                for (var _i = 0, _a = Object.entries(raw); _i < _a.length; _i++) {
+                    var _b = _a[_i], key = _b[0], value = _b[1];
+                    var normalizedKey = this.normalizeHintTargetKey(key);
+                    if (!normalizedKey)
+                        continue;
+                    addEntry(normalizedKey, value);
+                }
+            }
+        }
+        return cache.size ? cache : undefined;
+    };
+    JoinBuilder.prototype.getIndexHintClause = function (table, alias) {
+        var _a;
+        if (!this.indexHintCache) {
+            var rawHints = (_a = this.request) === null || _a === void 0 ? void 0 : _a[C6C.INDEX_HINTS];
+            this.indexHintCache = this.normalizeIndexHints(rawHints);
+        }
+        var hints = this.indexHintCache;
+        if (!hints || hints.size === 0)
+            return '';
+        var normalizedTable = this.normalizeHintTargetKey(table);
+        var normalizedAlias = alias ? this.normalizeHintTargetKey(alias) : undefined;
+        var candidates = [
+            normalizedAlias,
+            normalizedAlias ? "".concat(normalizedTable, " ").concat(normalizedAlias) : undefined,
+            normalizedTable,
+            '__base__',
+        ];
+        for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+            var candidate = candidates_1[_i];
+            if (!candidate)
+                continue;
+            var clause = hints.get(candidate);
+            if (clause)
+                return clause;
+        }
+        return '';
+    };
     JoinBuilder.prototype.buildJoinClauses = function (joinArgs, params) {
         var sql = '';
         var joinTypeEntries = joinArgs instanceof Map
@@ -2117,7 +2499,9 @@ var JoinBuilder = /** @class */ (function (_super) {
                     if (alias) {
                         this_1.registerAlias(alias, table);
                     }
-                    var joinSql = alias ? "`".concat(table, "` AS `").concat(alias, "`") : "`".concat(table, "`");
+                    var hintClause = this_1.getIndexHintClause(table, alias);
+                    var baseJoinSql = alias ? "`".concat(table, "` AS `").concat(alias, "`") : "`".concat(table, "`");
+                    var joinSql = hintClause ? "".concat(baseJoinSql, " ").concat(hintClause) : baseJoinSql;
                     var onClause = this_1.buildBooleanJoinedConditions(conditions, true, params);
                     sql += " ".concat(joinKind, " JOIN ").concat(joinSql);
                     if (onClause) {
@@ -2271,6 +2655,7 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
         // @ts-ignore
         if (this.selectAliases && this.selectAliases.clear)
             this.selectAliases.clear();
+        this.resetIndexHints();
         var args = this.request;
         this.initAlias(table, args.JOIN);
         var params = this.useNamedParams ? {} : [];
@@ -2279,6 +2664,10 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             .map(function (f) { return _this.buildAggregateField(f, params); })
             .join(', ');
         var sql = "SELECT ".concat(selectFields, " FROM `").concat(table, "`");
+        var baseIndexHint = this.getIndexHintClause(table);
+        if (baseIndexHint) {
+            sql += " ".concat(baseIndexHint);
+        }
         if (args.JOIN) {
             sql += this.buildJoinClauses(args.JOIN, params);
         }
@@ -2350,12 +2739,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        )");
@@ -2407,7 +2798,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) {
@@ -2735,12 +3128,12 @@ function ExpressHandler(_a) {
     var _this = this;
     var C6 = _a.C6, mysqlPool = _a.mysqlPool;
     return function (req, res, next) { return tslib.__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 tslib.__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 tslib.__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;
@@ -2754,7 +3147,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') {
@@ -2764,29 +3157,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({
@@ -2796,11 +3216,11 @@ function ExpressHandler(_a) {
                             restModel: C6.TABLES[table]
                         })(payload)];
                 case 1:
-                    response = _f.sent();
+                    response = _h.sent();
                     res.status(200).json(tslib.__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];
@@ -2885,10 +3305,11 @@ function error(message) {
 }
 
 function checkAllRequestsComplete() {
-    var stillRunning = exports.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(exports.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);
@@ -2930,6 +3351,7 @@ exports.SelectQueryBuilder = SelectQueryBuilder;
 exports.SqlExecutor = SqlExecutor;
 exports.TestRestfulResponse = TestRestfulResponse;
 exports.UpdateQueryBuilder = UpdateQueryBuilder;
+exports.apiRequestCache = apiRequestCache;
 exports.axiosInstance = axiosInstance;
 exports.bbox = bbox;
 exports.carbonNodeQsStringify = carbonNodeQsStringify;
@@ -2960,10 +3382,12 @@ exports.removePrefixIfExists = removePrefixIfExists;
 exports.resolveDerivedTable = resolveDerivedTable;
 exports.restOrm = restOrm;
 exports.restRequest = restRequest;
+exports.setCache = setCache;
 exports.sortAndSerializeQueryObject = sortAndSerializeQueryObject;
 exports.stContains = stContains;
 exports.timeout = timeout;
 exports.toastOptions = toastOptions;
 exports.toastOptionsDevs = toastOptionsDevs;
+exports.userCustomClearCache = userCustomClearCache;
 exports.warn = warn;
 //# sourceMappingURL=index.cjs.js.map