@carbonorm/carbonnode 3.5.7 → 3.5.9

package/dist/index.esm.js

@@ -1,11 +1,10 @@
 import axios from 'axios';
 import Qs from 'qs';
-import { __assign, __awaiter, __generator, __extends, __spreadArray } from 'tslib';
 import { toast } from 'react-toastify';
 import namedPlaceholders from 'named-placeholders';
 import { Buffer as Buffer$1 } from 'buffer';
 
-var C6Constants = {
+const C6Constants = {
     // try to 1=1 match the Rest abstract class
     ADDDATE: 'ADDDATE',
     ADDTIME: 'ADDTIME',
@@ -163,7 +162,7 @@ var C6Constants = {
     FINISH: 'FINISH',
     VALIDATE_C6_ENTITY_ID_REGEX: '#^([a-fA-F0-9]{20,35})$#',
 };
-var C6C = C6Constants;
+const C6C = C6Constants;
 
 // @link https://www.npmjs.com/package/axios-cache-adapter
 // updating these values
@@ -268,87 +267,100 @@ var axiosInstance = (axios.create({
     */
 }));
 
-function convertForRequestBody (restfulObject, tableName, C6, regexErrorHandler) {
-    if (regexErrorHandler === void 0) { regexErrorHandler = alert; }
-    var payload = {};
-    var tableNames = Array.isArray(tableName) ? tableName : [tableName];
-    var tableDefinitions = tableNames.map(function (name) {
-        var tableDefinition = Object.values(C6.TABLES).find(function (t) { return t.TABLE_NAME === name; });
+function convertForRequestBody (restfulObject, tableName, C6, regexErrorHandler = alert) {
+    const payload = {};
+    const tableNames = Array.isArray(tableName) ? tableName : [tableName];
+    const tableDefinitions = tableNames.map((name) => {
+        const tableDefinition = Object.values(C6.TABLES).find((t) => t.TABLE_NAME === name);
         if (!tableDefinition) {
-            console.error("Table name (".concat(name, ") is not found in the C6.TABLES object."), C6.TABLES);
-            throw new Error("Table name (".concat(name, ") is not found in the C6.TABLES object."));
+            console.error(`Table name (${name}) is not found in the C6.TABLES object.`, C6.TABLES);
+            throw new Error(`Table name (${name}) is not found in the C6.TABLES object.`);
         }
         return tableDefinition;
     });
-    for (var _i = 0, tableDefinitions_1 = tableDefinitions; _i < tableDefinitions_1.length; _i++) {
-        var tableDefinition = tableDefinitions_1[_i];
-        var _loop_1 = function (value) {
-            var shortReference = value.toUpperCase();
+    for (const tableDefinition of tableDefinitions) {
+        for (const value of Object.keys(restfulObject)) {
+            const shortReference = value.toUpperCase();
             if ([
                 C6Constants.GET,
+                C6Constants.SELECT,
+                C6Constants.INSERT,
                 C6Constants.POST,
                 C6Constants.UPDATE,
+                C6Constants.PUT,
                 C6Constants.REPLACE,
                 C6Constants.DELETE,
                 C6Constants.WHERE,
                 C6Constants.JOIN,
                 C6Constants.PAGINATION
             ].includes(value)) {
-                var val_1 = restfulObject[value];
-                if (Array.isArray(val_1)) {
-                    payload[value] = val_1.sort();
+                // TODO - pretty sure we could validate this better on the FED
+                const val = restfulObject[value];
+                if (Array.isArray(val)) {
+                    payload[value] = val.sort();
                 }
-                else if (typeof val_1 === 'object' && val_1 !== null) {
-                    payload[value] = Object.keys(val_1)
+                else if (typeof val === 'object' && val !== null) {
+                    payload[value] = Object.keys(val)
                         .sort()
-                        .reduce(function (acc, key) {
-                        var _a;
-                        return (__assign(__assign({}, acc), (_a = {}, _a[key] = val_1[key], _a)));
-                    }, {});
+                        .reduce((acc, key) => ({ ...acc, [key]: val[key] }), {});
                 }
-                return "continue";
+                continue;
             }
             if (shortReference in tableDefinition) {
-                var longName = tableDefinition[shortReference];
-                var columnValue = restfulObject[value];
+                const longName = tableDefinition[shortReference];
+                const columnValue = restfulObject[value];
                 payload[longName] = columnValue;
-                var regexValidations = tableDefinition.REGEX_VALIDATION[longName];
+                const regexValidations = tableDefinition.REGEX_VALIDATION[longName];
                 if (regexValidations instanceof RegExp) {
                     if (!regexValidations.test(columnValue)) {
-                        regexErrorHandler("Failed to match regex (".concat(regexValidations, ") for column (").concat(longName, ")"));
-                        throw new Error("Failed to match regex (".concat(regexValidations, ") for column (").concat(longName, ")"));
+                        regexErrorHandler(`Failed to match regex (${regexValidations}) for column (${longName})`);
+                        throw new Error(`Failed to match regex (${regexValidations}) for column (${longName})`);
                     }
                 }
                 else if (typeof regexValidations === 'object' && regexValidations !== null) {
-                    for (var errorMessage in regexValidations) {
-                        var regex = regexValidations[errorMessage];
+                    for (const errorMessage in regexValidations) {
+                        const regex = regexValidations[errorMessage];
                         if (!regex.test(columnValue)) {
-                            var devErrorMessage = "Failed to match regex (".concat(regex, ") for column (").concat(longName, ")");
+                            const devErrorMessage = `Failed to match regex (${regex}) for column (${longName})`;
+                            regexErrorHandler(errorMessage || devErrorMessage);
+                            throw new Error(devErrorMessage);
+                        }
+                    }
+                }
+            }
+            else if (value in Object.values(tableDefinition.COLUMNS)) {
+                // Already a fully qualified column name
+                const columnValue = restfulObject[value];
+                payload[value] = columnValue;
+                const regexValidations = tableDefinition.REGEX_VALIDATION[value];
+                if (regexValidations instanceof RegExp) {
+                    if (!regexValidations.test(columnValue)) {
+                        regexErrorHandler(`Failed to match regex (${regexValidations}) for column (${value})`);
+                        throw new Error(`Failed to match regex (${regexValidations}) for column (${value})`);
+                    }
+                }
+                else if (typeof regexValidations === 'object' && regexValidations !== null) {
+                    for (const errorMessage in regexValidations) {
+                        const regex = regexValidations[errorMessage];
+                        if (!regex.test(columnValue)) {
+                            const devErrorMessage = `Failed to match regex (${regex}) for column (${value})`;
                             regexErrorHandler(errorMessage || devErrorMessage);
                             throw new Error(devErrorMessage);
                         }
                     }
                 }
             }
-        };
-        for (var _a = 0, _b = Object.keys(restfulObject); _a < _b.length; _a++) {
-            var value = _b[_a];
-            _loop_1(value);
         }
     }
     return Object.keys(payload)
         .sort()
-        .reduce(function (acc, key) {
-        var _a;
-        return (__assign(__assign({}, acc), (_a = {}, _a[key] = payload[key], _a)));
-    }, {});
+        .reduce((acc, key) => ({ ...acc, [key]: payload[key] }), {});
 }
 
-var isNode = function () {
-    var _a;
+const isNode = () => {
     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));
+    const isNodeEnv = typeof process !== 'undefined' && !!process.versions?.node;
+    console.log(`Is Node.js environment: ${isNodeEnv}`);
     return isNodeEnv;
 };
 
@@ -356,112 +368,94 @@ var isNode = function () {
  * Facade: routes API calls to SQL or HTTP executors based on runtime context.
  */
 function restRequest(configX) {
-    var _this = this;
-    return function (request) { return __awaiter(_this, void 0, void 0, function () {
-        var config, SqlExecutor, executor, HttpExecutor, http;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    config = typeof configX === "function" ? configX() : configX;
-                    (_a = config.verbose) !== null && _a !== void 0 ? _a : (config.verbose = true); // Default to verbose logging if not set
-                    if (!(isNode() && config.mysqlPool)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, Promise.resolve().then(function () { return SqlExecutor$1; })];
-                case 1:
-                    SqlExecutor = (_b.sent()).SqlExecutor;
-                    executor = new SqlExecutor(config, request);
-                    return [2 /*return*/, executor.execute()];
-                case 2: return [4 /*yield*/, Promise.resolve().then(function () { return HttpExecutor$1; })];
-                case 3:
-                    HttpExecutor = (_b.sent()).HttpExecutor;
-                    http = new HttpExecutor(config, request);
-                    return [2 /*return*/, http.execute()];
-            }
-        });
-    }); };
+    return async (request) => {
+        const config = typeof configX === "function" ? configX() : configX;
+        config.verbose ??= true; // Default to verbose logging if not set
+        // SQL path if on Node with a provided pool
+        if (isNode() && config.mysqlPool) {
+            const { SqlExecutor } = await Promise.resolve().then(function () { return SqlExecutor$1; });
+            const executor = new SqlExecutor(config, request);
+            return executor.execute();
+        }
+        // HTTP path fallback
+        const { HttpExecutor } = await Promise.resolve().then(function () { return HttpExecutor$1; });
+        const http = new HttpExecutor(config, request);
+        return http.execute();
+    };
 }
 
 function restOrm(configFn) {
     return {
-        Get: restRequest(function () { return (__assign(__assign({}, configFn()), { requestMethod: "GET" })); }),
-        Put: restRequest(function () { return (__assign(__assign({}, configFn()), { requestMethod: "PUT" })); }),
-        Post: restRequest(function () { return (__assign(__assign({}, configFn()), { requestMethod: "POST" })); }),
-        Delete: restRequest(function () { return (__assign(__assign({}, configFn()), { requestMethod: "DELETE" })); })
+        Get: restRequest(() => ({
+            ...configFn(),
+            requestMethod: "GET"
+        })),
+        Put: restRequest(() => ({
+            ...configFn(),
+            requestMethod: "PUT"
+        })),
+        Post: restRequest(() => ({
+            ...configFn(),
+            requestMethod: "POST"
+        })),
+        Delete: restRequest(() => ({
+            ...configFn(),
+            requestMethod: "DELETE"
+        }))
     };
 }
 
-function timeout(shouldContinueAfterTimeout, cb, timeoutMs) {
-    if (timeoutMs === void 0) { timeoutMs = 3000; }
-    var timer = function () { return setTimeout(function () {
+function timeout(shouldContinueAfterTimeout, cb, timeoutMs = 3000) {
+    const timer = () => setTimeout(() => {
         if (false === shouldContinueAfterTimeout()) {
             return;
         }
         cb();
-    }, timeoutMs); };
-    var timerId = timer();
-    return function () {
+    }, timeoutMs);
+    const timerId = timer();
+    return () => {
         clearTimeout(timerId);
     };
 }
 
-var Executor = /** @class */ (function () {
-    function Executor(config, request, useNamedParams) {
-        if (useNamedParams === void 0) { useNamedParams = false; }
+class Executor {
+    config;
+    request;
+    useNamedParams;
+    constructor(config, request, useNamedParams = false) {
         this.config = config;
         this.request = request;
         this.useNamedParams = useNamedParams;
     }
-    Executor.prototype.runLifecycleHooks = function (phase, args) {
-        return __awaiter(this, void 0, void 0, function () {
-            var lifecycleGroup, _i, _a, _b, key, fn, err_1;
-            var _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        lifecycleGroup = (_c = this.config.restModel.LIFECYCLE_HOOKS[this.config.requestMethod]) === null || _c === void 0 ? void 0 : _c[phase];
-                        if (!lifecycleGroup)
-                            return [2 /*return*/];
-                        _i = 0, _a = Object.entries(lifecycleGroup);
-                        _d.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 6];
-                        _b = _a[_i], key = _b[0], fn = _b[1];
-                        if (!(typeof fn === "function")) return [3 /*break*/, 5];
-                        if (this.config.verbose || args.request.debug) {
-                            console.groupCollapsed("[LIFECYCLE] ".concat(this.config.requestMethod, ".").concat(String(phase), ":").concat(key));
-                            console.log("config:", args.config);
-                            console.log("request:", args.request);
-                            if ("response" in args) {
-                                console.log("response:", args.response);
-                            }
-                            console.groupEnd();
-                        }
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 4, , 5]);
-                        // todo - this
-                        return [4 /*yield*/, fn(args)];
-                    case 3:
-                        // todo - this
-                        _d.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        err_1 = _d.sent();
-                        console.error("[LIFECYCLE ERROR] ".concat(this.config.requestMethod, ".").concat(String(phase), ":").concat(key), err_1);
-                        throw err_1;
-                    case 5:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 6: return [2 /*return*/];
+    async runLifecycleHooks(phase, args) {
+        const lifecycleGroup = this.config.restModel.LIFECYCLE_HOOKS[this.config.requestMethod]?.[phase];
+        if (!lifecycleGroup)
+            return;
+        for (const [key, fn] of Object.entries(lifecycleGroup)) {
+            if (typeof fn === "function") {
+                if (this.config.verbose || args.request.debug) {
+                    console.groupCollapsed(`[LIFECYCLE] ${this.config.requestMethod}.${String(phase)}:${key}`);
+                    console.log("config:", args.config);
+                    console.log("request:", args.request);
+                    if ("response" in args) {
+                        console.log("response:", args.response);
+                    }
+                    console.groupEnd();
                 }
-            });
-        });
-    };
-    return Executor;
-}());
+                try {
+                    // todo - this
+                    await fn(args);
+                }
+                catch (err) {
+                    console.error(`[LIFECYCLE ERROR] ${this.config.requestMethod}.${String(phase)}:${key}`, err);
+                    throw err;
+                }
+            }
+        }
+    }
+}
 
-function getEnvVar(key, fallback) {
-    if (fallback === void 0) { fallback = ''; }
+function getEnvVar(key, fallback = '') {
     // Vite-style injection
     // @ts-ignore
     if (typeof import.meta !== 'undefined' && import.meta.env && key in import.meta.env) {
@@ -498,12 +492,12 @@ var eFetchDependencies;
 })(eFetchDependencies || (eFetchDependencies = {}));
 
 // Refined TypeScript types for CarbonORM
-var POST = 'POST';
-var PUT = 'PUT';
-var GET = 'GET';
-var DELETE = 'DELETE';
+const POST = 'POST';
+const PUT = 'PUT';
+const GET = 'GET';
+const DELETE = 'DELETE';
 
-var toastOptions = {
+const toastOptions = {
     position: "bottom-left",
     autoClose: 10000,
     hideProgressBar: false,
@@ -512,7 +506,7 @@ var toastOptions = {
     draggable: true,
     theme: "dark",
 };
-var toastOptionsDevs = {
+const toastOptionsDevs = {
     position: "bottom-right",
     autoClose: 3000,
     hideProgressBar: false,
@@ -524,20 +518,19 @@ var toastOptionsDevs = {
 
 // When we capture DropExceptions and display them as a custom page, this will change.
 function TestRestfulResponse(response, success, error) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    if (undefined === ((_a = response.data) === null || _a === void 0 ? void 0 : _a['ERROR TYPE'])
-        && (undefined !== ((_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.rest)
-            || undefined !== ((_c = response.data) === null || _c === void 0 ? void 0 : _c.created)
-            || undefined !== ((_d = response.data) === null || _d === void 0 ? void 0 : _d.updated)
-            || undefined !== ((_e = response.data) === null || _e === void 0 ? void 0 : _e.deleted))) {
-        var successReturn = 'function' === typeof success ? success === null || success === void 0 ? void 0 : success(response) : success;
+    if (undefined === response.data?.['ERROR TYPE']
+        && (undefined !== response?.data?.rest
+            || undefined !== response.data?.created
+            || undefined !== response.data?.updated
+            || undefined !== response.data?.deleted)) {
+        let successReturn = 'function' === typeof success ? success?.(response) : success;
         if (typeof successReturn === 'string') {
             toast.success(successReturn, toastOptions);
         }
         // this could end up with bad results for deleting id's === 0
-        return (_h = (_g = (_f = response.data.created) !== null && _f !== void 0 ? _f : response.data.updated) !== null && _g !== void 0 ? _g : response.data.deleted) !== null && _h !== void 0 ? _h : true;
+        return response.data.created ?? response.data.updated ?? response.data.deleted ?? true;
     }
-    var errorReturn = 'function' === typeof error ? error === null || error === void 0 ? void 0 : error(response) : error;
+    let errorReturn = 'function' === typeof error ? error?.(response) : error;
     if (typeof errorReturn === 'string') {
         toast.error(errorReturn, toastOptions);
     }
@@ -550,15 +543,15 @@ function removePrefixIfExists(tableName, prefix) {
     return tableName;
 }
 function removeInvalidKeys(request, c6Tables) {
-    var intersection = {};
-    var restfulObjectKeys = [];
-    var tableList = Object.values(c6Tables);
-    tableList.forEach(function (table) { return Object.values(table.COLUMNS).forEach(function (column) {
+    let intersection = {};
+    let restfulObjectKeys = [];
+    const tableList = Object.values(c6Tables);
+    tableList.forEach(table => Object.values(table.COLUMNS).forEach(column => {
         if (false === restfulObjectKeys.includes(column)) {
             restfulObjectKeys.push(column);
         }
-    }); });
-    Object.keys(request).forEach(function (key) {
+    }));
+    Object.keys(request).forEach(key => {
         if (restfulObjectKeys.includes(key)) {
             intersection[key] = request[key];
         }
@@ -569,13 +562,13 @@ function removeInvalidKeys(request, c6Tables) {
 
 // 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 = [];
-var userCustomClearCache = [];
+let apiRequestCache = [];
+let userCustomClearCache = [];
 function clearCache(props) {
-    if (false === (props === null || props === void 0 ? void 0 : props.ignoreWarning)) {
+    if (false === props?.ignoreWarning) {
         console.warn('The rest api clearCache should only be used with extreme care! Avoid using this in favor of using `cacheResults : boolean`.');
     }
-    userCustomClearCache.map(function (f) { return 'function' === typeof f && f(); });
+    userCustomClearCache.map((f) => 'function' === typeof f && f());
     userCustomClearCache = apiRequestCache = [];
 }
 function checkCache(cacheResult, requestMethod, tableName, request) {
@@ -590,601 +583,551 @@ function checkCache(cacheResult, requestMethod, tableName, request) {
 }
 
 function sortAndSerializeQueryObject(tables, query) {
-    var orderedQuery = Object.keys(query).sort().reduce(function (obj, key) {
+    const orderedQuery = Object.keys(query).sort().reduce((obj, key) => {
         obj[key] = query[key];
         return obj;
     }, {});
     return tables + ' ' + JSON.stringify(orderedQuery);
 }
 
-var HttpExecutor = /** @class */ (function (_super) {
-    __extends(HttpExecutor, _super);
-    function HttpExecutor() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    HttpExecutor.prototype.putState = function (response, request, callback) {
-        var _a, _b;
-        (_a = this.config.reactBootstrap) === null || _a === void 0 ? void 0 : _a.updateRestfulObjectArrays({
-            callback: callback,
+class HttpExecutor extends Executor {
+    putState(response, request, callback) {
+        this.config.reactBootstrap?.updateRestfulObjectArrays({
+            callback,
             dataOrCallback: [
-                removeInvalidKeys(__assign(__assign({}, request), (_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.rest), this.config.C6.TABLES)
+                removeInvalidKeys({
+                    ...request,
+                    ...response?.data?.rest,
+                }, this.config.C6.TABLES)
             ],
             stateKey: this.config.restModel.TABLE_NAME,
             uniqueObjectId: this.config.restModel.PRIMARY_SHORT
         });
-    };
-    HttpExecutor.prototype.postState = function (response, request, callback) {
-        var _this = this;
-        var _a, _b, _c;
+    }
+    postState(response, request, callback) {
         if (1 !== this.config.restModel.PRIMARY_SHORT.length) {
             console.error("C6 received unexpected result's given the primary key length");
         }
         else {
-            var pk = this.config.restModel.PRIMARY_SHORT[0];
+            const pk = this.config.restModel.PRIMARY_SHORT[0];
             // TODO - should overrides be handled differently? Why override: (react/php), driver missmatches, aux data..
             // @ts-ignore - this is technically a correct error, but we allow it anyway...
-            request[pk] = (_a = response.data) === null || _a === void 0 ? void 0 : _a.created;
+            request[pk] = response.data?.created;
         }
-        (_b = this.config.reactBootstrap) === null || _b === void 0 ? void 0 : _b.updateRestfulObjectArrays({
-            callback: callback,
+        this.config.reactBootstrap?.updateRestfulObjectArrays({
+            callback,
             dataOrCallback: undefined !== request.dataInsertMultipleRows
-                ? request.dataInsertMultipleRows.map(function (request, index) {
-                    var _a;
-                    return removeInvalidKeys(__assign(__assign({}, request), (index === 0 ? (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.rest : {})), _this.config.C6.TABLES);
+                ? request.dataInsertMultipleRows.map((request, index) => {
+                    return removeInvalidKeys({
+                        ...request,
+                        ...(index === 0 ? response?.data?.rest : {}),
+                    }, this.config.C6.TABLES);
                 })
                 : [
-                    removeInvalidKeys(__assign(__assign({}, request), (_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.rest), this.config.C6.TABLES)
+                    removeInvalidKeys({
+                        ...request,
+                        ...response?.data?.rest,
+                    }, this.config.C6.TABLES)
                 ],
             stateKey: this.config.restModel.TABLE_NAME,
             uniqueObjectId: this.config.restModel.PRIMARY_SHORT
         });
-    };
-    HttpExecutor.prototype.deleteState = function (_response, request, callback) {
-        var _a;
-        (_a = this.config.reactBootstrap) === null || _a === void 0 ? void 0 : _a.deleteRestfulObjectArrays({
-            callback: callback,
+    }
+    deleteState(_response, request, callback) {
+        this.config.reactBootstrap?.deleteRestfulObjectArrays({
+            callback,
             dataOrCallback: [
                 request,
             ],
             stateKey: this.config.restModel.TABLE_NAME,
             uniqueObjectId: this.config.restModel.PRIMARY_SHORT
         });
-    };
-    HttpExecutor.prototype.execute = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, C6, axios, restURL, withCredentials, restModel, reactBootstrap, requestMethod, skipPrimaryCheck, clearCache, tableName, fullTableList, operatingTableFullName, operatingTable, tables, query, apiRequest;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this.config, C6 = _a.C6, axios = _a.axios, restURL = _a.restURL, withCredentials = _a.withCredentials, restModel = _a.restModel, reactBootstrap = _a.reactBootstrap, requestMethod = _a.requestMethod, skipPrimaryCheck = _a.skipPrimaryCheck, clearCache = _a.clearCache;
-                        console.log('this.config', this.config);
-                        return [4 /*yield*/, this.runLifecycleHooks("beforeProcessing", {
-                                config: this.config,
-                                request: this.request,
-                            })];
-                    case 1:
-                        _b.sent();
-                        tableName = restModel.TABLE_NAME;
-                        fullTableList = Array.isArray(tableName) ? tableName : [tableName];
-                        operatingTableFullName = fullTableList[0];
-                        operatingTable = removePrefixIfExists(operatingTableFullName, C6.PREFIX);
-                        tables = fullTableList.join(',');
+    }
+    async execute() {
+        const { C6, axios, restURL, withCredentials, restModel, reactBootstrap, requestMethod, skipPrimaryCheck, clearCache, } = this.config;
+        console.log('this.config', this.config);
+        await this.runLifecycleHooks("beforeProcessing", {
+            config: this.config,
+            request: this.request,
+        });
+        const tableName = restModel.TABLE_NAME;
+        const fullTableList = Array.isArray(tableName) ? tableName : [tableName];
+        const operatingTableFullName = fullTableList[0];
+        const operatingTable = removePrefixIfExists(operatingTableFullName, C6.PREFIX);
+        const tables = fullTableList.join(',');
+        switch (requestMethod) {
+            case GET:
+            case POST:
+            case PUT:
+            case DELETE:
+                break;
+            default:
+                throw Error('Bad request method passed to getApi');
+        }
+        if (null !== clearCache || undefined !== clearCache) {
+            userCustomClearCache[tables + requestMethod] = clearCache;
+        }
+        console.groupCollapsed('%c API: (' + requestMethod + ') Request for (' + tableName + ')', 'color: #0c0');
+        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) {
+            console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + tableName + ') undefined, returning null (will not fire)!', 'color: #c00');
+            console.log('request', this.request);
+            console.log('%c Returning (undefined|null) for a query would indicate a custom cache hit (outside API.tsx), thus the request should not fire.', 'color: #c00');
+            console.trace();
+            console.groupEnd();
+            return null;
+        }
+        let query = this.request;
+        if (C6.GET === requestMethod) {
+            if (undefined === 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;
+        }
+        // this is parameterless and could return itself with a new page number, or undefined if the end is reached
+        const apiRequest = async () => {
+            const { debug, cacheResults = (C6.GET === requestMethod), dataInsertMultipleRows, success, fetchDependencies = eFetchDependencies.NONE, error = "An unexpected API error occurred!" } = this.request;
+            if (C6.GET === requestMethod
+                && undefined !== query?.[C6.PAGINATION]?.[C6.PAGE]
+                && 1 !== query[C6.PAGINATION][C6.PAGE]) {
+                console.groupCollapsed('Request on table (' + tableName + ') is firing for page (' + query[C6.PAGINATION][C6.PAGE] + '), please wait!');
+                console.log('Request Data (note you may see the success and/or error prompt):', this.request);
+                console.trace();
+                console.groupEnd();
+            }
+            // The problem with creating cache keys with a stringified object is the order of keys matters and it's possible for the same query to be stringified differently.
+            // Here we ensure the key order will be identical between two of the same requests. https://stackoverflow.com/questions/5467129/sort-javascript-object-by-key
+            // literally impossible for query to be undefined or null here but the editor is too busy licking windows to understand that
+            let querySerialized = sortAndSerializeQueryObject(tables, query ?? {});
+            let cacheResult = apiRequestCache.find(cache => cache.requestArgumentsSerialized === querySerialized);
+            let cachingConfirmed = false;
+            // determine if we need to paginate.
+            if (requestMethod === C6.GET) {
+                if (undefined === query?.[C6.PAGINATION]) {
+                    if (undefined === query || null === query) {
+                        query = {};
+                    }
+                    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;
+                // this will evaluate true most the time
+                if (true === cacheResults) {
+                    // just find the next, non-fetched, page and return a function to request it
+                    if (undefined !== cacheResult) { // we will return in this loop
+                        do {
+                            const cacheCheck = checkCache(cacheResult, requestMethod, tableName, this.request);
+                            if (false !== cacheCheck) {
+                                return (await cacheCheck).data;
+                            }
+                            // this line incrementing page is why we return recursively
+                            ++query[C6.PAGINATION][C6.PAGE];
+                            // this json stringify is to capture the new page number
+                            querySerialized = sortAndSerializeQueryObject(tables, query ?? {});
+                            cacheResult = apiRequestCache.find(cache => cache.requestArgumentsSerialized === querySerialized);
+                        } while (undefined !== cacheResult);
+                        if (debug && isLocal()) {
+                            toast.warning("DEVS: Request in cache. (" + apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized) + "). Returning function to request page (" + query[C6.PAGINATION][C6.PAGE] + ")", toastOptionsDevs);
+                        }
+                        // @ts-ignore - this is an incorrect warning on TS, it's well typed
+                        return apiRequest;
+                    }
+                    cachingConfirmed = true;
+                }
+                else {
+                    if (debug && isLocal()) {
+                        toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
+                    }
+                }
+                if (debug && isLocal()) {
+                    toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? "Page (" + query[C6.PAGINATION][C6.PAGE] + ")." : '') + " Logging cache 2 console.", toastOptionsDevs);
+                }
+            }
+            else if (cacheResults) { // if we are not getting, we are updating, deleting, or inserting
+                if (cacheResult) {
+                    const cacheCheck = checkCache(cacheResult, requestMethod, tableName, this.request);
+                    if (false !== cacheCheck) {
+                        return (await cacheCheck).data;
+                    }
+                }
+                cachingConfirmed = true;
+                // push to cache so we do not repeat the request
+            }
+            let addBackPK;
+            let apiResponse;
+            let returnGetNextPageFunction = false;
+            let restRequestUri = restURL + operatingTable + '/';
+            const needsConditionOrPrimaryCheck = (PUT === requestMethod || DELETE === requestMethod)
+                && false === skipPrimaryCheck;
+            const TABLES = C6.TABLES;
+            // todo - aggregate primary key check with condition check
+            // check if PK exists in query, clone so pop does not affect the real data
+            const primaryKey = structuredClone(TABLES[operatingTable]?.PRIMARY)?.pop()?.split('.')?.pop();
+            if (needsConditionOrPrimaryCheck) {
+                if (undefined === primaryKey) {
+                    if (null === query
+                        || undefined === query
+                        || undefined === query?.[C6.WHERE]
+                        || (true === Array.isArray(query[C6.WHERE])
+                            || query[C6.WHERE].length === 0)
+                        || (Object.keys(query?.[C6.WHERE]).length === 0)) {
+                        console.error(query);
+                        throw Error('Failed to parse primary key information. Query: (' + JSON.stringify(query) + ') Primary Key: (' + JSON.stringify(primaryKey) + ') TABLES[operatingTable]?.PRIMARY: (' + JSON.stringify(TABLES[operatingTable]?.PRIMARY) + ') for operatingTable (' + operatingTable + ').');
+                    }
+                }
+                else {
+                    if (undefined === query
+                        || null === query
+                        || false === primaryKey in query) {
+                        if (true === debug && isLocal()) {
+                            toast.error('DEVS: The primary key (' + primaryKey + ') was not provided!!');
+                        }
+                        throw Error('You must provide the primary key (' + primaryKey + ') for table (' + operatingTable + '). Request (' + JSON.stringify(this.request, undefined, 4) + ') Query (' + JSON.stringify(query) + ')');
+                    }
+                    if (undefined === query?.[primaryKey]
+                        || null === query?.[primaryKey]) {
+                        toast.error('The primary key (' + primaryKey + ') provided is undefined or null explicitly!!');
+                        throw Error('The primary key (' + primaryKey + ') provided in the request was exactly equal to undefined.');
+                    }
+                }
+            }
+            // A part of me exists that wants to remove this, but it's a good feature
+            // this allows developers the ability to cache requests based on primary key
+            // for tables like `photos` this can be a huge performance boost
+            if (undefined !== query
+                && null !== query
+                && undefined !== primaryKey
+                && primaryKey in query) {
+                restRequestUri += query[primaryKey] + '/';
+                const removedPkValue = query[primaryKey];
+                addBackPK = () => {
+                    query ??= {};
+                    query[primaryKey] = removedPkValue;
+                };
+                delete query[primaryKey];
+                console.log('query', query, 'primaryKey', primaryKey, 'removedPkValue', removedPkValue);
+            }
+            else {
+                console.log('query', query);
+            }
+            try {
+                console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + operatingTable + ') is about to fire, will return with promise!', 'color: #A020F0');
+                console.log(this.request);
+                console.log('%c If this is the first request for this datatype; thus the value being set is currently undefined, please remember to update the state to null.', 'color: #A020F0');
+                console.log('%c Remember undefined indicated the request has not fired, null indicates the request is firing, an empty array would signal no data was returned for the sql stmt.', 'color: #A020F0');
+                console.trace();
+                console.groupEnd();
+                this.runLifecycleHooks("beforeExecution", {
+                    config: this.config,
+                    request: this.request
+                });
+                const axiosActiveRequest = axios[requestMethod.toLowerCase()](restRequestUri, ...(() => {
+                    const convert = (data) => convertForRequestBody(data, fullTableList, C6, (message) => toast.error(message, toastOptions));
+                    const baseConfig = {
+                        withCredentials: withCredentials,
+                    };
+                    switch (requestMethod) {
+                        case GET:
+                            return [{
+                                    ...baseConfig,
+                                    params: query
+                                }];
+                        case POST:
+                            if (dataInsertMultipleRows !== undefined) {
+                                return [
+                                    dataInsertMultipleRows.map(convert),
+                                    baseConfig
+                                ];
+                            }
+                            return [convert(query), baseConfig];
+                        case PUT:
+                            return [convert(query), baseConfig];
+                        case DELETE:
+                            return [{
+                                    ...baseConfig,
+                                    data: convert(query)
+                                }];
+                        default:
+                            throw new Error(`The request method (${requestMethod}) was not recognized.`);
+                    }
+                })());
+                if (cachingConfirmed) {
+                    // push to cache so we do not repeat the request
+                    apiRequestCache.push({
+                        requestArgumentsSerialized: querySerialized,
+                        request: axiosActiveRequest
+                    });
+                }
+                // todo - wip verify this works
+                // we had removed the value from the request to add to the URI.
+                addBackPK?.(); // adding back so post-processing methods work
+                // returning the promise with this then is important for tests. todo - we could make that optional.
+                // https://rapidapi.com/guides/axios-async-await
+                return axiosActiveRequest.then(async (response) => {
+                    // noinspection SuspiciousTypeOfGuard
+                    if (typeof response.data === 'string') {
+                        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 + ')');
+                        }
+                        return Promise.reject(response);
+                    }
+                    if (cachingConfirmed) {
+                        const cacheIndex = apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized);
+                        // TODO - currently nonthing is setting this correctly
+                        apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction;
+                        // only cache get method requests
+                        apiRequestCache[cacheIndex].response = response;
+                    }
+                    this.runLifecycleHooks("afterExecution", {
+                        config: this.config,
+                        request: this.request,
+                        response
+                    });
+                    // todo - this feels dumb now, but i digress
+                    apiResponse = TestRestfulResponse(response, success, error);
+                    if (false === apiResponse) {
+                        if (debug && isLocal()) {
+                            toast.warning("DEVS: TestRestfulResponse returned false for (" + operatingTable + ").", toastOptionsDevs);
+                        }
+                        return response;
+                    }
+                    const callback = () => this.runLifecycleHooks("afterCommit", {
+                        config: this.config,
+                        request: this.request,
+                        response
+                    });
+                    if (undefined !== reactBootstrap && response) {
                         switch (requestMethod) {
                             case GET:
+                                response.data && reactBootstrap.updateRestfulObjectArrays({
+                                    dataOrCallback: Array.isArray(response.data.rest) ? response.data.rest : [response.data.rest],
+                                    stateKey: this.config.restModel.TABLE_NAME,
+                                    uniqueObjectId: this.config.restModel.PRIMARY_SHORT,
+                                    callback
+                                });
+                                break;
                             case POST:
+                                this.postState(response, this.request, callback);
+                                break;
                             case PUT:
+                                this.putState(response, this.request, callback);
+                                break;
                             case DELETE:
+                                this.deleteState(response, this.request, callback);
                                 break;
-                            default:
-                                throw Error('Bad request method passed to getApi');
                         }
-                        if (null !== clearCache || undefined !== clearCache) {
-                            userCustomClearCache[tables + requestMethod] = clearCache;
-                        }
-                        console.groupCollapsed('%c API: (' + requestMethod + ') Request for (' + tableName + ')', 'color: #0c0');
-                        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) {
-                            console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + tableName + ') undefined, returning null (will not fire)!', 'color: #c00');
-                            console.log('request', this.request);
-                            console.log('%c Returning (undefined|null) for a query would indicate a custom cache hit (outside API.tsx), thus the request should not fire.', 'color: #c00');
+                    }
+                    else {
+                        callback();
+                    }
+                    if (C6.GET === requestMethod) {
+                        const responseData = response.data;
+                        returnGetNextPageFunction = 1 !== query?.[C6.PAGINATION]?.[C6.LIMIT] &&
+                            query?.[C6.PAGINATION]?.[C6.LIMIT] === responseData.rest.length;
+                        if (false === isTest() || this.config.verbose) {
+                            console.groupCollapsed('%c API: Response (' + requestMethod + ' ' + tableName + ') returned length (' + responseData.rest?.length + ') of possible (' + query?.[C6.PAGINATION]?.[C6.LIMIT] + ') limit!', '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', this.request);
+                            console.log('%c Response Data:', 'color: #0c0', responseData.rest);
+                            console.log('%c Will return get next page function:' + (returnGetNextPageFunction ? '' : ' (Will not return with explicit limit 1 set)'), 'color: #0c0', true === returnGetNextPageFunction);
                             console.trace();
                             console.groupEnd();
-                            return [2 /*return*/, null];
                         }
-                        query = this.request;
-                        if (C6.GET === requestMethod) {
-                            if (undefined === query[C6.PAGINATION]) {
-                                query[C6.PAGINATION] = {};
+                        if (false === returnGetNextPageFunction) {
+                            responseData.next = apiRequest;
+                        }
+                        else {
+                            responseData.next = undefined;
+                            if (true === debug
+                                && isLocal()) {
+                                toast.success("DEVS: Response returned length (" + responseData.rest?.length + ") less than limit (" + query?.[C6.PAGINATION]?.[C6.LIMIT] + ").", toastOptionsDevs);
                             }
-                            query[C6.PAGINATION][C6.PAGE] = query[C6.PAGINATION][C6.PAGE] || 1;
-                            query[C6.PAGINATION][C6.LIMIT] = query[C6.PAGINATION][C6.LIMIT] || 100;
                         }
-                        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, addBackPK, apiResponse, returnGetNextPageFunction, restRequestUri, needsConditionOrPrimaryCheck, TABLES, primaryKey, removedPkValue_1, axiosActiveRequest;
-                            var _e;
-                            var _this = this;
-                            var _f, _g, _h, _j, _k, _l;
-                            return __generator(this, function (_m) {
-                                switch (_m.label) {
-                                    case 0:
-                                        _a = this.request, debug = _a.debug, _b = _a.cacheResults, cacheResults = _b === void 0 ? (C6.GET === requestMethod) : _b, dataInsertMultipleRows = _a.dataInsertMultipleRows, success = _a.success, _c = _a.fetchDependencies, fetchDependencies = _c === void 0 ? eFetchDependencies.NONE : _c, _d = _a.error, error = _d === void 0 ? "An unexpected API error occurred!" : _d;
-                                        if (C6.GET === requestMethod
-                                            && undefined !== ((_f = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _f === void 0 ? void 0 : _f[C6.PAGE])
-                                            && 1 !== query[C6.PAGINATION][C6.PAGE]) {
-                                            console.groupCollapsed('Request on table (' + tableName + ') is firing for page (' + query[C6.PAGINATION][C6.PAGE] + '), please wait!');
-                                            console.log('Request Data (note you may see the success and/or error prompt):', this.request);
-                                            console.trace();
-                                            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 = {};
-                                            }
-                                            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;
-                                        if (!(true === cacheResults)) return [3 /*break*/, 7];
-                                        if (!(undefined !== cacheResult)) return [3 /*break*/, 6];
-                                        _m.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*/, (_m.sent()).data];
-                                    case 3:
-                                        // this line incrementing page is why we return recursively
-                                        ++query[C6.PAGINATION][C6.PAGE];
-                                        // this json stringify is to capture the new page number
-                                        querySerialized = sortAndSerializeQueryObject(tables, query !== null && query !== void 0 ? query : {});
-                                        cacheResult = apiRequestCache.find(function (cache) { return cache.requestArgumentsSerialized === querySerialized; });
-                                        _m.label = 4;
-                                    case 4:
-                                        if (undefined !== cacheResult) return [3 /*break*/, 1];
-                                        _m.label = 5;
-                                    case 5:
-                                        if (debug && isLocal()) {
-                                            toast.warning("DEVS: Request in cache. (" + apiRequestCache.findIndex(function (cache) { return cache.requestArgumentsSerialized === querySerialized; }) + "). Returning function to request page (" + query[C6.PAGINATION][C6.PAGE] + ")", toastOptionsDevs);
-                                        }
-                                        // @ts-ignore - this is an incorrect warning on TS, it's well typed
-                                        return [2 /*return*/, apiRequest];
-                                    case 6:
-                                        cachingConfirmed = true;
-                                        return [3 /*break*/, 8];
-                                    case 7:
-                                        if (debug && isLocal()) {
-                                            toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
-                                        }
-                                        _m.label = 8;
-                                    case 8:
-                                        if (debug && isLocal()) {
-                                            toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? "Page (" + query[C6.PAGINATION][C6.PAGE] + ")." : '') + " Logging cache 2 console.", 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*/, (_m.sent()).data];
-                                    case 11:
-                                        cachingConfirmed = true;
-                                        _m.label = 12;
-                                    case 12:
-                                        returnGetNextPageFunction = false;
-                                        restRequestUri = restURL + operatingTable + '/';
-                                        needsConditionOrPrimaryCheck = (PUT === requestMethod || DELETE === requestMethod)
-                                            && false === skipPrimaryCheck;
-                                        TABLES = C6.TABLES;
-                                        primaryKey = (_k = (_j = (_h = structuredClone((_g = TABLES[operatingTable]) === null || _g === void 0 ? void 0 : _g.PRIMARY)) === null || _h === void 0 ? void 0 : _h.pop()) === null || _j === void 0 ? void 0 : _j.split('.')) === null || _k === void 0 ? void 0 : _k.pop();
-                                        if (needsConditionOrPrimaryCheck) {
-                                            if (undefined === primaryKey) {
-                                                if (null === query
-                                                    || undefined === query
-                                                    || undefined === (query === null || query === void 0 ? void 0 : query[C6.WHERE])
-                                                    || (true === Array.isArray(query[C6.WHERE])
-                                                        || query[C6.WHERE].length === 0)
-                                                    || (Object.keys(query === null || query === void 0 ? void 0 : query[C6.WHERE]).length === 0)) {
-                                                    console.error(query);
-                                                    throw Error('Failed to parse primary key information. Query: (' + JSON.stringify(query) + ') Primary Key: (' + JSON.stringify(primaryKey) + ') TABLES[operatingTable]?.PRIMARY: (' + JSON.stringify((_l = TABLES[operatingTable]) === null || _l === void 0 ? void 0 : _l.PRIMARY) + ') for operatingTable (' + operatingTable + ').');
-                                                }
-                                            }
-                                            else {
-                                                if (undefined === query
-                                                    || null === query
-                                                    || false === primaryKey in query) {
-                                                    if (true === debug && isLocal()) {
-                                                        toast.error('DEVS: The primary key (' + primaryKey + ') was not provided!!');
-                                                    }
-                                                    throw Error('You must provide the primary key (' + primaryKey + ') for table (' + operatingTable + '). Request (' + JSON.stringify(this.request, undefined, 4) + ') Query (' + JSON.stringify(query) + ')');
-                                                }
-                                                if (undefined === (query === null || query === void 0 ? void 0 : query[primaryKey])
-                                                    || null === (query === null || query === void 0 ? void 0 : query[primaryKey])) {
-                                                    toast.error('The primary key (' + primaryKey + ') provided is undefined or null explicitly!!');
-                                                    throw Error('The primary key (' + primaryKey + ') provided in the request was exactly equal to undefined.');
+                        if (fetchDependencies
+                            && 'number' === typeof fetchDependencies
+                            && responseData.rest.length > 0) {
+                            console.groupCollapsed('%c API: Fetch Dependencies segment (' + requestMethod + ' ' + tableName + ')'
+                                + (fetchDependencies & eFetchDependencies.CHILDREN ? ' | (CHILDREN|REFERENCED) ' : '')
+                                + (fetchDependencies & eFetchDependencies.PARENTS ? ' | (PARENTS|REFERENCED_BY)' : '')
+                                + (fetchDependencies & eFetchDependencies.C6ENTITY ? ' | (C6ENTITY)' : '')
+                                + (fetchDependencies & eFetchDependencies.RECURSIVE ? ' | (RECURSIVE)' : ''), 'color: #33ccff');
+                            console.groupCollapsed('Collapsed JS Trace');
+                            console.trace(); // hidden in collapsed group
+                            console.groupEnd();
+                            // noinspection JSBitwiseOperatorUsage
+                            let dependencies = {};
+                            // Remember this is a binary bitwise operation, so we can check for multiple dependencies at once
+                            if (fetchDependencies & eFetchDependencies.C6ENTITY) {
+                                dependencies = operatingTable.endsWith("carbon_carbons")
+                                    ? {
+                                        // the context of the entity system is a bit different
+                                        ...fetchDependencies & eFetchDependencies.CHILDREN // REFERENCED === CHILDREN
+                                            ? C6.TABLES[operatingTable].TABLE_REFERENCED_BY
+                                            : {},
+                                        ...fetchDependencies & eFetchDependencies.PARENTS // REFERENCES === PARENTS
+                                            ? C6.TABLES[operatingTable].TABLE_REFERENCES
+                                            : {}
+                                    } : {
+                                    // the context of the entity system is a bit different
+                                    ...fetchDependencies & eFetchDependencies.CHILDREN // REFERENCED === CHILDREN
+                                        ? {
+                                            ...Object.keys(C6.TABLES[operatingTable].TABLE_REFERENCES).reduce((accumulator, columnName) => {
+                                                if (!C6.TABLES[operatingTable].PRIMARY_SHORT.includes(columnName)) {
+                                                    accumulator[columnName] = C6.TABLES[operatingTable].TABLE_REFERENCES[columnName];
                                                 }
-                                            }
-                                        }
-                                        // A part of me exists that wants to remove this, but it's a good feature
-                                        // this allows developers the ability to cache requests based on primary key
-                                        // for tables like `photos` this can be a huge performance boost
-                                        if (undefined !== query
-                                            && null !== query
-                                            && undefined !== primaryKey
-                                            && primaryKey in query) {
-                                            restRequestUri += query[primaryKey] + '/';
-                                            removedPkValue_1 = query[primaryKey];
-                                            addBackPK = function () {
-                                                query !== null && query !== void 0 ? query : (query = {});
-                                                query[primaryKey] = removedPkValue_1;
-                                            };
-                                            delete query[primaryKey];
-                                            console.log('query', query, 'primaryKey', primaryKey, 'removedPkValue', removedPkValue_1);
-                                        }
-                                        else {
-                                            console.log('query', query);
+                                                return accumulator;
+                                            }, {}),
+                                            ...C6.TABLES[operatingTable].TABLE_REFERENCED_BY // it is unlikely that a C6 table will have any TABLE_REFERENCED_BY
                                         }
-                                        try {
-                                            console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + operatingTable + ') is about to fire, will return with promise!', 'color: #A020F0');
-                                            console.log(this.request);
-                                            console.log('%c If this is the first request for this datatype; thus the value being set is currently undefined, please remember to update the state to null.', 'color: #A020F0');
-                                            console.log('%c Remember undefined indicated the request has not fired, null indicates the request is firing, an empty array would signal no data was returned for the sql stmt.', 'color: #A020F0');
-                                            console.trace();
-                                            console.groupEnd();
-                                            this.runLifecycleHooks("beforeExecution", {
-                                                config: this.config,
-                                                request: this.request
-                                            });
-                                            axiosActiveRequest = (_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); });
-                                                };
-                                                var baseConfig = {
-                                                    withCredentials: withCredentials,
-                                                };
-                                                switch (requestMethod) {
-                                                    case GET:
-                                                        return [__assign(__assign({}, baseConfig), { params: query })];
-                                                    case POST:
-                                                        if (dataInsertMultipleRows !== undefined) {
-                                                            return [
-                                                                dataInsertMultipleRows.map(convert),
-                                                                baseConfig
-                                                            ];
-                                                        }
-                                                        return [convert(query), baseConfig];
-                                                    case PUT:
-                                                        return [convert(query), baseConfig];
-                                                    case DELETE:
-                                                        return [__assign(__assign({}, baseConfig), { data: convert(query) })];
-                                                    default:
-                                                        throw new Error("The request method (".concat(requestMethod, ") was not recognized."));
-                                                }
-                                            })(), false));
-                                            if (cachingConfirmed) {
-                                                // push to cache so we do not repeat the request
-                                                apiRequestCache.push({
-                                                    requestArgumentsSerialized: querySerialized,
-                                                    request: axiosActiveRequest
-                                                });
+                                        : {},
+                                    ...fetchDependencies & eFetchDependencies.PARENTS // REFERENCES === PARENTS
+                                        ? C6.TABLES[operatingTable].PRIMARY_SHORT.reduce((accumulator, primaryKey) => {
+                                            if (primaryKey in C6.TABLES[operatingTable].TABLE_REFERENCES) {
+                                                accumulator[primaryKey] = C6.TABLES[operatingTable].TABLE_REFERENCES[primaryKey];
                                             }
-                                            // todo - wip verify this works
-                                            // we had removed the value from the request to add to the URI.
-                                            addBackPK === null || addBackPK === void 0 ? void 0 : addBackPK(); // adding back so post-processing methods work
-                                            // 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, dependencies_1, fetchReferences_1, apiRequestPromises, _loop_1, _a, _b, _c, _i, tableToFetch;
-                                                    var _this = this;
-                                                    var _d, _e, _f, _g, _h, _j;
-                                                    return __generator(this, function (_k) {
-                                                        switch (_k.label) {
-                                                            case 0:
-                                                                // noinspection SuspiciousTypeOfGuard
-                                                                if (typeof response.data === 'string') {
-                                                                    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 + ')');
-                                                                    }
-                                                                    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;
-                                                                }
-                                                                this.runLifecycleHooks("afterExecution", {
-                                                                    config: this.config,
-                                                                    request: this.request,
-                                                                    response: response
-                                                                });
-                                                                // todo - this feels dumb now, but i digress
-                                                                apiResponse = TestRestfulResponse(response, success, error);
-                                                                if (false === apiResponse) {
-                                                                    if (debug && isLocal()) {
-                                                                        toast.warning("DEVS: TestRestfulResponse returned false for (" + operatingTable + ").", toastOptionsDevs);
-                                                                    }
-                                                                    return [2 /*return*/, response];
-                                                                }
-                                                                callback = function () { return _this.runLifecycleHooks("afterCommit", {
-                                                                    config: _this.config,
-                                                                    request: _this.request,
-                                                                    response: response
-                                                                }); };
-                                                                if (undefined !== reactBootstrap && response) {
-                                                                    switch (requestMethod) {
-                                                                        case GET:
-                                                                            response.data && reactBootstrap.updateRestfulObjectArrays({
-                                                                                dataOrCallback: Array.isArray(response.data.rest) ? response.data.rest : [response.data.rest],
-                                                                                stateKey: this.config.restModel.TABLE_NAME,
-                                                                                uniqueObjectId: this.config.restModel.PRIMARY_SHORT,
-                                                                                callback: callback
-                                                                            });
-                                                                            break;
-                                                                        case POST:
-                                                                            this.postState(response, this.request, callback);
-                                                                            break;
-                                                                        case PUT:
-                                                                            this.putState(response, this.request, callback);
-                                                                            break;
-                                                                        case DELETE:
-                                                                            this.deleteState(response, this.request, callback);
-                                                                            break;
-                                                                    }
-                                                                }
-                                                                else {
-                                                                    callback();
-                                                                }
-                                                                if (!(C6.GET === requestMethod)) return [3 /*break*/, 6];
-                                                                responseData_1 = response.data;
-                                                                returnGetNextPageFunction = 1 !== ((_d = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _d === void 0 ? void 0 : _d[C6.LIMIT]) &&
-                                                                    ((_e = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _e === void 0 ? void 0 : _e[C6.LIMIT]) === responseData_1.rest.length;
-                                                                if (false === isTest() || this.config.verbose) {
-                                                                    console.groupCollapsed('%c API: Response (' + requestMethod + ' ' + tableName + ') returned length (' + ((_f = responseData_1.rest) === null || _f === void 0 ? void 0 : _f.length) + ') of possible (' + ((_g = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _g === void 0 ? void 0 : _g[C6.LIMIT]) + ') limit!', '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', this.request);
-                                                                    console.log('%c Response Data:', 'color: #0c0', responseData_1.rest);
-                                                                    console.log('%c Will return get next page function:' + (returnGetNextPageFunction ? '' : ' (Will not return with explicit limit 1 set)'), 'color: #0c0', true === returnGetNextPageFunction);
-                                                                    console.trace();
-                                                                    console.groupEnd();
-                                                                }
-                                                                if (false === returnGetNextPageFunction) {
-                                                                    responseData_1.next = apiRequest;
-                                                                }
-                                                                else {
-                                                                    responseData_1.next = undefined;
-                                                                    if (true === debug
-                                                                        && isLocal()) {
-                                                                        toast.success("DEVS: Response returned length (" + ((_h = responseData_1.rest) === null || _h === void 0 ? void 0 : _h.length) + ") less than limit (" + ((_j = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _j === void 0 ? void 0 : _j[C6.LIMIT]) + ").", toastOptionsDevs);
-                                                                    }
-                                                                }
-                                                                if (!(fetchDependencies
-                                                                    && 'number' === typeof fetchDependencies
-                                                                    && responseData_1.rest.length > 0)) return [3 /*break*/, 6];
-                                                                console.groupCollapsed('%c API: Fetch Dependencies segment (' + requestMethod + ' ' + tableName + ')'
-                                                                    + (fetchDependencies & eFetchDependencies.CHILDREN ? ' | (CHILDREN|REFERENCED) ' : '')
-                                                                    + (fetchDependencies & eFetchDependencies.PARENTS ? ' | (PARENTS|REFERENCED_BY)' : '')
-                                                                    + (fetchDependencies & eFetchDependencies.C6ENTITY ? ' | (C6ENTITY)' : '')
-                                                                    + (fetchDependencies & eFetchDependencies.RECURSIVE ? ' | (RECURSIVE)' : ''), 'color: #33ccff');
-                                                                console.groupCollapsed('Collapsed JS Trace');
-                                                                console.trace(); // hidden in collapsed group
-                                                                console.groupEnd();
-                                                                dependencies_1 = {};
-                                                                // Remember this is a binary bitwise operation, so we can check for multiple dependencies at once
-                                                                if (fetchDependencies & eFetchDependencies.C6ENTITY) {
-                                                                    dependencies_1 = operatingTable.endsWith("carbon_carbons")
-                                                                        ? __assign(__assign({}, fetchDependencies & eFetchDependencies.CHILDREN // REFERENCED === CHILDREN
-                                                                            ? C6.TABLES[operatingTable].TABLE_REFERENCED_BY
-                                                                            : {}), fetchDependencies & eFetchDependencies.PARENTS // REFERENCES === PARENTS
-                                                                            ? C6.TABLES[operatingTable].TABLE_REFERENCES
-                                                                            : {}) : __assign(__assign({}, fetchDependencies & eFetchDependencies.CHILDREN // REFERENCED === CHILDREN
-                                                                        ? __assign(__assign({}, Object.keys(C6.TABLES[operatingTable].TABLE_REFERENCES).reduce(function (accumulator, columnName) {
-                                                                            if (!C6.TABLES[operatingTable].PRIMARY_SHORT.includes(columnName)) {
-                                                                                accumulator[columnName] = C6.TABLES[operatingTable].TABLE_REFERENCES[columnName];
-                                                                            }
-                                                                            return accumulator;
-                                                                        }, {})), C6.TABLES[operatingTable].TABLE_REFERENCED_BY // it is unlikely that a C6 table will have any TABLE_REFERENCED_BY
-                                                                        ) : {}), fetchDependencies & eFetchDependencies.PARENTS // REFERENCES === PARENTS
-                                                                        ? C6.TABLES[operatingTable].PRIMARY_SHORT.reduce(function (accumulator, primaryKey) {
-                                                                            if (primaryKey in C6.TABLES[operatingTable].TABLE_REFERENCES) {
-                                                                                accumulator[primaryKey] = C6.TABLES[operatingTable].TABLE_REFERENCES[primaryKey];
-                                                                            }
-                                                                            return accumulator;
-                                                                        }, {})
-                                                                        : {});
-                                                                }
-                                                                else {
-                                                                    // this is the natural mysql context
-                                                                    dependencies_1 = __assign(__assign({}, fetchDependencies & eFetchDependencies.REFERENCED // REFERENCED === CHILDREN
-                                                                        ? C6.TABLES[operatingTable].TABLE_REFERENCED_BY
-                                                                        : {}), fetchDependencies & eFetchDependencies.REFERENCES // REFERENCES === PARENTS
-                                                                        ? C6.TABLES[operatingTable].TABLE_REFERENCES
-                                                                        : {});
-                                                                }
-                                                                fetchReferences_1 = {};
-                                                                apiRequestPromises = [];
-                                                                console.log('%c Dependencies', 'color: #005555', dependencies_1);
-                                                                Object.keys(dependencies_1)
-                                                                    .forEach(function (column) { return dependencies_1[column]
-                                                                    .forEach(function (constraint) {
-                                                                    var _a, _b, _c, _d;
-                                                                    var _e, _f, _g;
-                                                                    var columnValues = (_b = (_a = responseData_1.rest[column]) !== null && _a !== void 0 ? _a : responseData_1.rest.map(function (row) {
-                                                                        if (operatingTable.endsWith("carbons")
-                                                                            && 'entity_tag' in row
-                                                                            && !constraint.TABLE.endsWith(row['entity_tag'].split('\\').pop().toLowerCase())) {
-                                                                            return false; // map
-                                                                        }
-                                                                        if (!(column in row)) {
-                                                                            return false;
-                                                                        }
-                                                                        // todo - row[column] is a FK value, we should optionally remove values that are already in state
-                                                                        // this could be any column in the table constraint.TABLE, not just the primary key
-                                                                        return row[column];
-                                                                    }).filter(function (n) { return n; })) !== null && _b !== void 0 ? _b : [];
-                                                                    if (columnValues.length === 0) {
-                                                                        return; // forEach
-                                                                    }
-                                                                    (_c = fetchReferences_1[_e = constraint.TABLE]) !== null && _c !== void 0 ? _c : (fetchReferences_1[_e] = {});
-                                                                    (_d = (_f = fetchReferences_1[constraint.TABLE])[_g = constraint.COLUMN]) !== null && _d !== void 0 ? _d : (_f[_g] = []);
-                                                                    fetchReferences_1[constraint.TABLE][constraint.COLUMN].push(columnValues);
-                                                                }); });
-                                                                console.log('fetchReferences', fetchReferences_1);
-                                                                _loop_1 = function (tableToFetch) {
-                                                                    var referencesTables, shouldContinue, fetchTable, RestApi, nextFetchDependencies;
-                                                                    var _l;
-                                                                    return __generator(this, function (_m) {
-                                                                        switch (_m.label) {
-                                                                            case 0:
-                                                                                if (fetchDependencies & eFetchDependencies.C6ENTITY
-                                                                                    && 'string' === typeof tableName
-                                                                                    && tableName.endsWith("carbon_carbons")) {
-                                                                                    referencesTables = responseData_1.rest.reduce(function (accumulator, row) {
-                                                                                        if ('entity_tag' in row && !accumulator.includes(row['entity_tag'])) {
-                                                                                            accumulator.push(row['entity_tag']);
-                                                                                        }
-                                                                                        return accumulator;
-                                                                                    }, []).map(function (entityTag) { return entityTag.split('\\').pop().toLowerCase(); });
-                                                                                    shouldContinue = referencesTables.find(function (referencesTable) { return tableToFetch.endsWith(referencesTable); });
-                                                                                    if (!shouldContinue) {
-                                                                                        console.log('%c C6ENTITY: The constraintTableName (' + tableToFetch + ') did not end with any value in referencesTables', 'color: #c00', referencesTables);
-                                                                                        return [2 /*return*/, "continue"];
-                                                                                    }
-                                                                                    console.log('%c C6ENTITY: The constraintTableName (' + tableToFetch + ') will be fetched.', 'color: #0c0');
-                                                                                }
-                                                                                return [4 /*yield*/, C6.IMPORT(tableToFetch)];
-                                                                            case 1:
-                                                                                fetchTable = _m.sent();
-                                                                                RestApi = fetchTable.default;
-                                                                                console.log('%c Fetch Dependencies will select (' + tableToFetch + ') using GET request', 'color: #33ccff');
-                                                                                nextFetchDependencies = eFetchDependencies.NONE;
-                                                                                if (fetchDependencies & eFetchDependencies.RECURSIVE) {
-                                                                                    if (fetchDependencies & eFetchDependencies.ALL) {
-                                                                                        throw Error('Recursive fetch dependencies with both PARENT and CHILD reference will result in an infin1ite loop. As there is not real ending condition, this is not supported.');
-                                                                                    }
-                                                                                    nextFetchDependencies = fetchDependencies;
-                                                                                }
-                                                                                else if (fetchDependencies & eFetchDependencies.C6ENTITY) {
-                                                                                    if (tableToFetch === "carbon_carbons") {
-                                                                                        nextFetchDependencies = fetchDependencies;
-                                                                                    }
-                                                                                    else {
-                                                                                        nextFetchDependencies = fetchDependencies ^ eFetchDependencies.C6ENTITY;
-                                                                                    }
-                                                                                }
-                                                                                console.log('fetchReferences', fetchReferences_1[tableToFetch], "Current fetchDependencies for (" + operatingTable + "):", fetchDependencies, "New fetchDependencies for (" + tableToFetch + "): ", nextFetchDependencies);
-                                                                                // todo - filter out ids that exist in state?!? note - remember that this does not necessarily mean the pk, but only known is its an FK to somewhere
-                                                                                // it not certain that they are using carbons' entities either
-                                                                                // 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((_l = {},
-                                                                                    _l[C6.WHERE] = {
-                                                                                        0: 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);
-                                                                                                return false;
-                                                                                            }
-                                                                                            sum[column] = fetchReferences_1[tableToFetch][column].length === 1
-                                                                                                ? fetchReferences_1[tableToFetch][column][0]
-                                                                                                : [
-                                                                                                    C6.IN, fetchReferences_1[tableToFetch][column]
-                                                                                                ];
-                                                                                            return sum;
-                                                                                        }, {})
-                                                                                    },
-                                                                                    _l.fetchDependencies = nextFetchDependencies,
-                                                                                    _l)));
-                                                                                return [2 /*return*/];
-                                                                        }
-                                                                    });
-                                                                };
-                                                                _a = fetchReferences_1;
-                                                                _b = [];
-                                                                for (_c in _a)
-                                                                    _b.push(_c);
-                                                                _i = 0;
-                                                                _k.label = 1;
-                                                            case 1:
-                                                                if (!(_i < _b.length)) return [3 /*break*/, 4];
-                                                                _c = _b[_i];
-                                                                if (!(_c in _a)) return [3 /*break*/, 3];
-                                                                tableToFetch = _c;
-                                                                return [5 /*yield**/, _loop_1(tableToFetch)];
-                                                            case 2:
-                                                                _k.sent();
-                                                                _k.label = 3;
-                                                            case 3:
-                                                                _i++;
-                                                                return [3 /*break*/, 1];
-                                                            case 4:
-                                                                console.groupEnd();
-                                                                return [4 /*yield*/, Promise.all(apiRequestPromises)];
-                                                            case 5:
-                                                                _k.sent();
-                                                                apiRequestPromises.map(function (promise) { return __awaiter(_this, void 0, void 0, function () {
-                                                                    var _a, _b;
-                                                                    return __generator(this, function (_c) {
-                                                                        switch (_c.label) {
-                                                                            case 0:
-                                                                                if (!Array.isArray(this.request.fetchDependencies)) {
-                                                                                    // to reassign value we must ref the root
-                                                                                    this.request.fetchDependencies = [];
-                                                                                }
-                                                                                _b = (_a = this.request.fetchDependencies).push;
-                                                                                return [4 /*yield*/, promise];
-                                                                            case 1:
-                                                                                _b.apply(_a, [_c.sent()]);
-                                                                                return [2 /*return*/];
-                                                                        }
-                                                                    });
-                                                                }); });
-                                                                _k.label = 6;
-                                                            case 6:
-                                                                if (debug && isLocal()) {
-                                                                    toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
-                                                                }
-                                                                // this is the literal axios return
-                                                                return [2 /*return*/, response];
-                                                        }
-                                                    });
-                                                }); }).then(function (response) { return response.data; })]; // this escapes from axios context
+                                            return accumulator;
+                                        }, {})
+                                        : {}
+                                };
+                            }
+                            else {
+                                // this is the natural mysql context
+                                dependencies = {
+                                    ...fetchDependencies & eFetchDependencies.REFERENCED // REFERENCED === CHILDREN
+                                        ? C6.TABLES[operatingTable].TABLE_REFERENCED_BY
+                                        : {},
+                                    ...fetchDependencies & eFetchDependencies.REFERENCES // REFERENCES === PARENTS
+                                        ? C6.TABLES[operatingTable].TABLE_REFERENCES
+                                        : {}
+                                };
+                            }
+                            let fetchReferences = {};
+                            let apiRequestPromises = [];
+                            console.log('%c Dependencies', 'color: #005555', dependencies);
+                            Object.keys(dependencies)
+                                .forEach(column => dependencies[column]
+                                .forEach((constraint) => {
+                                const columnValues = responseData.rest[column] ?? responseData.rest.map((row) => {
+                                    if (operatingTable.endsWith("carbons")
+                                        && 'entity_tag' in row
+                                        && !constraint.TABLE.endsWith(row['entity_tag'].split('\\').pop().toLowerCase())) {
+                                        return false; // map
+                                    }
+                                    if (!(column in row)) {
+                                        return false;
+                                    }
+                                    // todo - row[column] is a FK value, we should optionally remove values that are already in state
+                                    // this could be any column in the table constraint.TABLE, not just the primary key
+                                    return row[column];
+                                }).filter(n => n) ?? [];
+                                if (columnValues.length === 0) {
+                                    return; // forEach
+                                }
+                                fetchReferences[constraint.TABLE] ??= {};
+                                fetchReferences[constraint.TABLE][constraint.COLUMN] ??= [];
+                                fetchReferences[constraint.TABLE][constraint.COLUMN].push(columnValues);
+                            }));
+                            console.log('fetchReferences', fetchReferences);
+                            for (const tableToFetch in fetchReferences) {
+                                if (fetchDependencies & eFetchDependencies.C6ENTITY
+                                    && 'string' === typeof tableName
+                                    && tableName.endsWith("carbon_carbons")) {
+                                    // todo - rethink the table ref entity system - when tables are renamed? no hooks exist in mysql
+                                    // since were already filtering on column, we can assume the first row constraint is the same as the rest
+                                    const referencesTables = responseData.rest.reduce((accumulator, row) => {
+                                        if ('entity_tag' in row && !accumulator.includes(row['entity_tag'])) {
+                                            accumulator.push(row['entity_tag']);
                                         }
-                                        catch (throwableError) {
-                                            if (isTest()) {
-                                                throw new Error(JSON.stringify(throwableError));
+                                        return accumulator;
+                                    }, []).map((entityTag) => entityTag.split('\\').pop().toLowerCase());
+                                    const shouldContinue = referencesTables.find((referencesTable) => tableToFetch.endsWith(referencesTable));
+                                    if (!shouldContinue) {
+                                        console.log('%c C6ENTITY: The constraintTableName (' + tableToFetch + ') did not end with any value in referencesTables', 'color: #c00', referencesTables);
+                                        continue;
+                                    }
+                                    console.log('%c C6ENTITY: The constraintTableName (' + tableToFetch + ') will be fetched.', 'color: #0c0');
+                                }
+                                const fetchTable = await C6.IMPORT(tableToFetch);
+                                const RestApi = fetchTable.default;
+                                console.log('%c Fetch Dependencies will select (' + tableToFetch + ') using GET request', 'color: #33ccff');
+                                let nextFetchDependencies = eFetchDependencies.NONE;
+                                if (fetchDependencies & eFetchDependencies.RECURSIVE) {
+                                    if (fetchDependencies & eFetchDependencies.ALL) {
+                                        throw Error('Recursive fetch dependencies with both PARENT and CHILD reference will result in an infin1ite loop. As there is not real ending condition, this is not supported.');
+                                    }
+                                    nextFetchDependencies = fetchDependencies;
+                                }
+                                else if (fetchDependencies & eFetchDependencies.C6ENTITY) {
+                                    if (tableToFetch === "carbon_carbons") {
+                                        nextFetchDependencies = fetchDependencies;
+                                    }
+                                    else {
+                                        nextFetchDependencies = fetchDependencies ^ eFetchDependencies.C6ENTITY;
+                                    }
+                                }
+                                console.log('fetchReferences', fetchReferences[tableToFetch], "Current fetchDependencies for (" + operatingTable + "):", fetchDependencies, "New fetchDependencies for (" + tableToFetch + "): ", nextFetchDependencies);
+                                // todo - filter out ids that exist in state?!? note - remember that this does not necessarily mean the pk, but only known is its an FK to somewhere
+                                // it not certain that they are using carbons' entities either
+                                // 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({
+                                    [C6.WHERE]: {
+                                        0: Object.keys(fetchReferences[tableToFetch]).reduce((sum, column) => {
+                                            fetchReferences[tableToFetch][column] = fetchReferences[tableToFetch][column].flat(Infinity);
+                                            if (0 === fetchReferences[tableToFetch][column].length) {
+                                                console.warn('The column (' + column + ') was not found in the response data. We will not fetch.', responseData);
+                                                return false;
                                             }
-                                            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.trace();
-                                            console.groupEnd();
-                                            TestRestfulResponse(throwableError, success, error);
-                                            return [2 /*return*/, null];
-                                        }
-                                        return [2 /*return*/];
+                                            sum[column] = fetchReferences[tableToFetch][column].length === 1
+                                                ? fetchReferences[tableToFetch][column][0]
+                                                : [
+                                                    C6.IN, fetchReferences[tableToFetch][column]
+                                                ];
+                                            return sum;
+                                        }, {})
+                                    },
+                                    fetchDependencies: nextFetchDependencies
+                                }));
+                            }
+                            console.groupEnd();
+                            await Promise.all(apiRequestPromises);
+                            apiRequestPromises.map(async (promise) => {
+                                if (!Array.isArray(this.request.fetchDependencies)) {
+                                    // to reassign value we must ref the root
+                                    this.request.fetchDependencies = [];
                                 }
+                                this.request.fetchDependencies.push(await promise);
                             });
-                        }); };
-                        return [4 /*yield*/, apiRequest()];
-                    case 2: return [2 /*return*/, _b.sent()];
+                        }
+                    }
+                    if (debug && isLocal()) {
+                        toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
+                    }
+                    // this is the literal axios return
+                    return response;
+                }).then(response => response.data); // this escapes from axios context
+            }
+            catch (throwableError) {
+                if (isTest()) {
+                    throw new Error(JSON.stringify(throwableError));
                 }
-            });
-        });
-    };
-    return HttpExecutor;
-}(Executor));
+                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.trace();
+                console.groupEnd();
+                TestRestfulResponse(throwableError, success, error);
+                return null;
+            }
+        };
+        return await apiRequest();
+    }
+}
 
 var HttpExecutor$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1201,210 +1144,188 @@ function convertHexIfBinary(_col, val, columnDef) {
     return val;
 }
 
-var AggregateBuilder = /** @class */ (function (_super) {
-    __extends(AggregateBuilder, _super);
-    function AggregateBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    AggregateBuilder.prototype.buildAggregateField = function (field) {
-        var _this = this;
+class AggregateBuilder extends Executor {
+    buildAggregateField(field) {
         if (typeof field === 'string') {
             return field;
         }
         if (!Array.isArray(field) || field.length === 0) {
             throw new Error('Invalid SELECT field entry');
         }
-        var fn = field[0], args = field.slice(1);
-        var alias;
+        let [fn, ...args] = field;
+        let alias;
         if (args.length >= 2 && String(args[args.length - 2]).toUpperCase() === 'AS') {
             alias = String(args.pop());
             args.pop();
         }
-        var F = String(fn).toUpperCase();
-        var argList = args.map(function (arg) {
-            return Array.isArray(arg) ? _this.buildAggregateField(arg) : arg;
-        }).join(', ');
-        var expr = "".concat(F, "(").concat(argList, ")");
+        const F = String(fn).toUpperCase();
+        const argList = args.map(arg => Array.isArray(arg) ? this.buildAggregateField(arg) : arg).join(', ');
+        let expr = `${F}(${argList})`;
         if (alias) {
-            expr += " AS ".concat(alias);
+            expr += ` AS ${alias}`;
         }
-        this.config.verbose && console.log("[SELECT] ".concat(expr));
+        this.config.verbose && console.log(`[SELECT] ${expr}`);
         return expr;
-    };
-    return AggregateBuilder;
-}(Executor));
-
-var ConditionBuilder = /** @class */ (function (_super) {
-    __extends(ConditionBuilder, _super);
-    function ConditionBuilder() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.aliasMap = {};
-        _this.OPERATORS = new Set([
-            C6C.EQUAL, C6C.NOT_EQUAL, C6C.LESS_THAN, C6C.LESS_THAN_OR_EQUAL_TO,
-            C6C.GREATER_THAN, C6C.GREATER_THAN_OR_EQUAL_TO,
-            C6C.LIKE, C6C.NOT_LIKE,
-            C6C.IN, C6C.NOT_IN, 'NOT IN',
-            C6C.IS, C6C.IS_NOT,
-            C6C.BETWEEN, 'NOT BETWEEN',
-            C6C.MATCH_AGAINST,
-            C6C.ST_DISTANCE_SPHERE
-        ]);
-        return _this;
     }
-    ConditionBuilder.prototype.initAlias = function (baseTable, joins) {
-        var _a;
-        this.aliasMap = (_a = {}, _a[baseTable] = baseTable, _a);
+}
+
+class ConditionBuilder extends AggregateBuilder {
+    aliasMap = {};
+    initAlias(baseTable, joins) {
+        this.aliasMap = { [baseTable]: baseTable };
         if (!joins)
             return;
-        for (var joinType in joins) {
-            for (var raw in joins[joinType]) {
-                var _b = raw.split(' '), table = _b[0], alias = _b[1];
+        for (const joinType in joins) {
+            for (const raw in joins[joinType]) {
+                const [table, alias] = raw.split(' ');
                 this.aliasMap[alias || table] = table;
             }
         }
-    };
-    ConditionBuilder.prototype.isColumnRef = function (ref) {
-        var _a, _b;
+    }
+    isColumnRef(ref) {
         if (typeof ref !== 'string' || !ref.includes('.'))
             return false;
-        var _c = ref.split('.', 2), prefix = _c[0], column = _c[1];
-        var tableName = this.aliasMap[prefix] || prefix;
-        var table = (_b = (_a = this.config.C6) === null || _a === void 0 ? void 0 : _a.TABLES) === null || _b === void 0 ? void 0 : _b[tableName];
+        const [prefix, column] = ref.split('.', 2);
+        const tableName = this.aliasMap[prefix] || prefix;
+        const table = this.config.C6?.TABLES?.[tableName];
         if (!table)
             return false;
-        var fullKey = "".concat(tableName, ".").concat(column);
+        const fullKey = `${tableName}.${column}`;
         if (table.COLUMNS && (fullKey in table.COLUMNS))
             return true;
         if (table.COLUMNS && Object.values(table.COLUMNS).includes(ref))
             return true;
-        this.config.verbose && console.log("[COLUMN REF] ".concat(ref, " is not a valid column reference"));
+        this.config.verbose && console.log(`[COLUMN REF] ${ref} is not a valid column reference`);
         return false;
-    };
-    ConditionBuilder.prototype.execute = function () {
+    }
+    execute() {
         throw new Error("Method not implemented.");
-    };
-    ConditionBuilder.prototype.validateOperator = function (op) {
+    }
+    OPERATORS = new Set([
+        C6C.EQUAL, C6C.NOT_EQUAL, C6C.LESS_THAN, C6C.LESS_THAN_OR_EQUAL_TO,
+        C6C.GREATER_THAN, C6C.GREATER_THAN_OR_EQUAL_TO,
+        C6C.LIKE, C6C.NOT_LIKE,
+        C6C.IN, C6C.NOT_IN, 'NOT IN',
+        C6C.IS, C6C.IS_NOT,
+        C6C.BETWEEN, 'NOT BETWEEN',
+        C6C.MATCH_AGAINST,
+        C6C.ST_DISTANCE_SPHERE
+    ]);
+    validateOperator(op) {
         if (!this.OPERATORS.has(op)) {
-            throw new Error("Invalid or unsupported SQL operator detected: '".concat(op, "'"));
+            throw new Error(`Invalid or unsupported SQL operator detected: '${op}'`);
         }
-    };
-    ConditionBuilder.prototype.addParam = function (params, column, value) {
-        var _a, _b;
-        var columnDef = (_b = (_a = this.config.C6[column.split('.')[0]]) === null || _a === void 0 ? void 0 : _a.TYPE_VALIDATION) === null || _b === void 0 ? void 0 : _b[column];
-        var val = convertHexIfBinary(column, value, columnDef);
+    }
+    addParam(params, column, value) {
+        const columnDef = this.config.C6[column.split('.')[0]]?.TYPE_VALIDATION?.[column];
+        const val = convertHexIfBinary(column, value, columnDef);
         if (this.useNamedParams) {
-            var key = "param".concat(Object.keys(params).length);
+            const key = `param${Object.keys(params).length}`;
             params[key] = val;
-            return ":".concat(key);
+            return `:${key}`;
         }
         else {
             params.push(val);
             return '?';
         }
-    };
-    ConditionBuilder.prototype.buildBooleanJoinedConditions = function (set, andMode, params) {
-        var _this = this;
-        if (andMode === void 0) { andMode = true; }
-        if (params === void 0) { params = []; }
-        var booleanOperator = andMode ? 'AND' : 'OR';
-        var addCondition = function (column, op, value) {
+    }
+    buildBooleanJoinedConditions(set, andMode = true, params = []) {
+        const booleanOperator = andMode ? 'AND' : 'OR';
+        const addCondition = (column, op, value) => {
             // Support function-based expressions like [C6C.ST_DISTANCE_SPHERE, col1, col2]
             if (typeof column === 'string' &&
-                _this.OPERATORS.has(column) &&
+                this.OPERATORS.has(column) &&
                 Array.isArray(op)) {
                 if (column === C6C.ST_DISTANCE_SPHERE) {
-                    var col1 = op[0], col2 = op[1];
-                    var threshold = Array.isArray(value) ? value[0] : value;
-                    return "ST_Distance_Sphere(".concat(col1, ", ").concat(col2, ") < ").concat(_this.addParam(params, '', threshold));
+                    const [col1, col2] = op;
+                    const threshold = Array.isArray(value) ? value[0] : value;
+                    return `ST_Distance_Sphere(${col1}, ${col2}) < ${this.addParam(params, '', threshold)}`;
                 }
             }
-            var leftIsCol = _this.isColumnRef(column);
-            var rightIsCol = typeof value === 'string' && _this.isColumnRef(value);
+            const leftIsCol = this.isColumnRef(column);
+            const rightIsCol = typeof value === 'string' && this.isColumnRef(value);
             if (!leftIsCol && !rightIsCol) {
-                throw new Error("Potential SQL injection detected: '".concat(column, " ").concat(op, " ").concat(value, "'"));
+                throw new Error(`Potential SQL injection detected: '${column} ${op} ${value}'`);
             }
-            _this.validateOperator(op);
+            this.validateOperator(op);
             if (op === C6C.MATCH_AGAINST && Array.isArray(value)) {
-                var search = value[0], mode = value[1];
-                var paramName = _this.useNamedParams ? "param".concat(Object.keys(params).length) : null;
-                if (_this.useNamedParams) {
+                const [search, mode] = value;
+                const paramName = this.useNamedParams ? `param${Object.keys(params).length}` : null;
+                if (this.useNamedParams) {
                     params[paramName] = search;
                 }
                 else {
                     params.push(search);
                 }
-                var againstClause = void 0;
+                let againstClause;
                 switch ((mode || '').toUpperCase()) {
                     case 'BOOLEAN':
-                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, " IN BOOLEAN MODE)") : "AGAINST(? IN BOOLEAN MODE)";
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName} IN BOOLEAN MODE)` : `AGAINST(? IN BOOLEAN MODE)`;
                         break;
                     case 'WITH QUERY EXPANSION':
-                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, " WITH QUERY EXPANSION)") : "AGAINST(? WITH QUERY EXPANSION)";
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName} WITH QUERY EXPANSION)` : `AGAINST(? WITH QUERY EXPANSION)`;
                         break;
                     default: // NATURAL or undefined
-                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, ")") : "AGAINST(?)";
+                        againstClause = this.useNamedParams ? `AGAINST(:${paramName})` : `AGAINST(?)`;
                         break;
                 }
                 if (!leftIsCol) {
-                    throw new Error("MATCH_AGAINST requires a table reference as the left operand. Column '".concat(column, "' is not a valid table reference."));
+                    throw new Error(`MATCH_AGAINST requires a table reference as the left operand. Column '${column}' is not a valid table reference.`);
                 }
-                var matchClause = "(MATCH(".concat(column, ") ").concat(againstClause, ")");
-                _this.config.verbose && console.log("[MATCH_AGAINST] ".concat(matchClause));
+                const matchClause = `(MATCH(${column}) ${againstClause})`;
+                this.config.verbose && console.log(`[MATCH_AGAINST] ${matchClause}`);
                 return matchClause;
             }
             if ((op === C6C.IN || op === C6C.NOT_IN) && Array.isArray(value)) {
-                var placeholders = value.map(function (v) {
-                    return _this.isColumnRef(v) ? v : _this.addParam(params, column, v);
-                }).join(', ');
-                var normalized = op.replace('_', ' ');
+                const placeholders = value.map(v => this.isColumnRef(v) ? v : this.addParam(params, column, v)).join(', ');
+                const normalized = op.replace('_', ' ');
                 if (!leftIsCol) {
-                    throw new Error("IN operator requires a table reference as the left operand. Column '".concat(column, "' is not a valid table reference."));
+                    throw new Error(`IN operator requires a table reference as the left operand. Column '${column}' is not a valid table reference.`);
                 }
-                return "( ".concat(column, " ").concat(normalized, " (").concat(placeholders, ") )");
+                return `( ${column} ${normalized} (${placeholders}) )`;
             }
             if (op === C6C.BETWEEN || op === 'NOT BETWEEN') {
                 if (!Array.isArray(value) || value.length !== 2) {
-                    throw new Error("BETWEEN operator requires an array of two values. Received: ".concat(JSON.stringify(value)));
+                    throw new Error(`BETWEEN operator requires an array of two values. Received: ${JSON.stringify(value)}`);
                 }
-                var start = value[0], end = value[1];
+                const [start, end] = value;
                 if (!leftIsCol) {
-                    throw new Error("BETWEEN operator requires a table reference as the left operand. Column '".concat(column, "' is not a valid table reference."));
+                    throw new Error(`BETWEEN operator requires a table reference as the left operand. Column '${column}' is not a valid table reference.`);
                 }
-                return "(".concat(column, ") ").concat(op.replace('_', ' '), " ").concat(_this.addParam(params, column, start), " AND ").concat(_this.addParam(params, column, end));
+                return `(${column}) ${op.replace('_', ' ')} ${this.addParam(params, column, start)} AND ${this.addParam(params, column, end)}`;
             }
             if (leftIsCol && rightIsCol) {
-                return "(".concat(column, ") ").concat(op, " ").concat(value);
+                return `(${column}) ${op} ${value}`;
             }
             if (leftIsCol && !rightIsCol) {
-                return "(".concat(column, ") ").concat(op, " ").concat(_this.addParam(params, column, value));
+                return `(${column}) ${op} ${this.addParam(params, column, value)}`;
             }
             if (rightIsCol) {
-                return "(".concat(_this.addParam(params, column, column), ") ").concat(op, " ").concat(value);
+                return `(${this.addParam(params, column, column)}) ${op} ${value}`;
             }
-            throw new Error("Neither operand appears to be a table reference");
+            throw new Error(`Neither operand appears to be a table reference`);
         };
-        var parts = [];
-        var buildFromObject = function (obj, mode) {
-            var subParts = [];
-            for (var _i = 0, _a = Object.entries(obj); _i < _a.length; _i++) {
-                var _b = _a[_i], k = _b[0], v = _b[1];
+        const parts = [];
+        const buildFromObject = (obj, mode) => {
+            const subParts = [];
+            for (const [k, v] of Object.entries(obj)) {
                 // numeric keys represent nested OR groups
                 if (!isNaN(Number(k))) {
-                    var sub = _this.buildBooleanJoinedConditions(v, false, params);
+                    const sub = this.buildBooleanJoinedConditions(v, false, params);
                     if (sub)
                         subParts.push(sub);
                     continue;
                 }
                 if (typeof v === 'object' && v !== null && Object.keys(v).length === 1) {
-                    var _c = Object.entries(v)[0], op = _c[0], val = _c[1];
+                    const [op, val] = Object.entries(v)[0];
                     subParts.push(addCondition(k, op, val));
                 }
                 else if (Array.isArray(v) && v.length >= 2 && typeof v[0] === 'string') {
-                    var _d = v, op = _d[0], val = _d[1];
+                    const [op, val] = v;
                     subParts.push(addCondition(k, op, val));
                 }
                 else if (typeof v === 'object' && v !== null) {
-                    var sub = _this.buildBooleanJoinedConditions(v, mode, params);
+                    const sub = this.buildBooleanJoinedConditions(v, mode, params);
                     if (sub)
                         subParts.push(sub);
                 }
@@ -1412,124 +1333,105 @@ var ConditionBuilder = /** @class */ (function (_super) {
                     subParts.push(addCondition(k, '=', v));
                 }
             }
-            return subParts.join(" ".concat(mode ? 'AND' : 'OR', " "));
+            return subParts.join(` ${mode ? 'AND' : 'OR'} `);
         };
         if (Array.isArray(set)) {
-            for (var _i = 0, set_1 = set; _i < set_1.length; _i++) {
-                var item = set_1[_i];
-                var sub = this.buildBooleanJoinedConditions(item, false, params);
+            for (const item of set) {
+                const sub = this.buildBooleanJoinedConditions(item, false, params);
                 if (sub)
                     parts.push(sub);
             }
         }
         else if (typeof set === 'object' && set !== null) {
-            var sub = buildFromObject(set, andMode);
+            const sub = buildFromObject(set, andMode);
             if (sub)
                 parts.push(sub);
         }
-        var clause = parts.join(" ".concat(booleanOperator, " "));
-        return clause ? "(".concat(clause, ")") : '';
-    };
-    ConditionBuilder.prototype.buildWhereClause = function (whereArg, params) {
-        var clause = this.buildBooleanJoinedConditions(whereArg, true, params);
+        const clause = parts.join(` ${booleanOperator} `);
+        return clause ? `(${clause})` : '';
+    }
+    buildWhereClause(whereArg, params) {
+        const clause = this.buildBooleanJoinedConditions(whereArg, true, params);
         if (!clause)
             return '';
-        var trimmed = clause.replace(/^\((.*)\)$/, '$1');
-        this.config.verbose && console.log("[WHERE] ".concat(trimmed));
-        return " WHERE ".concat(trimmed);
-    };
-    return ConditionBuilder;
-}(AggregateBuilder));
-
-var JoinBuilder = /** @class */ (function (_super) {
-    __extends(JoinBuilder, _super);
-    function JoinBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        const trimmed = clause.replace(/^\((.*)\)$/, '$1');
+        this.config.verbose && console.log(`[WHERE] ${trimmed}`);
+        return ` WHERE ${trimmed}`;
     }
-    JoinBuilder.prototype.buildJoinClauses = function (joinArgs, params) {
-        var sql = '';
-        for (var joinType in joinArgs) {
-            var joinKind = joinType.replace('_', ' ').toUpperCase();
-            for (var raw in joinArgs[joinType]) {
-                var _a = raw.split(' '), table = _a[0], alias = _a[1];
+}
+
+class JoinBuilder extends ConditionBuilder {
+    buildJoinClauses(joinArgs, params) {
+        let sql = '';
+        for (const joinType in joinArgs) {
+            const joinKind = joinType.replace('_', ' ').toUpperCase();
+            for (const raw in joinArgs[joinType]) {
+                const [table, alias] = raw.split(' ');
                 this.aliasMap[alias || table] = table;
-                var onClause = this.buildBooleanJoinedConditions(joinArgs[joinType][raw], true, params);
-                var joinSql = alias ? "`".concat(table, "` AS `").concat(alias, "`") : "`".concat(table, "`");
-                sql += " ".concat(joinKind, " JOIN ").concat(joinSql, " ON ").concat(onClause);
+                const onClause = this.buildBooleanJoinedConditions(joinArgs[joinType][raw], true, params);
+                const joinSql = alias ? `\`${table}\` AS \`${alias}\`` : `\`${table}\``;
+                sql += ` ${joinKind} JOIN ${joinSql} ON ${onClause}`;
             }
         }
-        this.config.verbose && console.log("[JOIN] ".concat(sql.trim()));
+        this.config.verbose && console.log(`[JOIN] ${sql.trim()}`);
         return sql;
-    };
-    return JoinBuilder;
-}(ConditionBuilder));
-
-var DeleteQueryBuilder = /** @class */ (function (_super) {
-    __extends(DeleteQueryBuilder, _super);
-    function DeleteQueryBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    DeleteQueryBuilder.prototype.build = function (table) {
-        var params = this.useNamedParams ? {} : [];
+}
+
+class DeleteQueryBuilder extends JoinBuilder {
+    build(table) {
+        const params = this.useNamedParams ? {} : [];
         this.initAlias(table, this.request.JOIN);
-        var sql = "DELETE `".concat(table, "` FROM `").concat(table, "`");
+        let sql = `DELETE \`${table}\` FROM \`${table}\``;
         if (this.request.JOIN) {
             sql += this.buildJoinClauses(this.request.JOIN, params);
         }
         if (this.request.WHERE) {
             sql += this.buildWhereClause(this.request.WHERE, params);
         }
-        return { sql: sql, params: params };
-    };
-    return DeleteQueryBuilder;
-}(JoinBuilder));
-
-var PostQueryBuilder = /** @class */ (function (_super) {
-    __extends(PostQueryBuilder, _super);
-    function PostQueryBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        return { sql, params };
     }
-    PostQueryBuilder.prototype.trimTablePrefix = function (table, column) {
+}
+
+class PostQueryBuilder extends ConditionBuilder {
+    trimTablePrefix(table, column) {
         if (!column.includes('.'))
             return column;
-        var _a = column.split('.', 2), prefix = _a[0], col = _a[1];
+        const [prefix, col] = column.split('.', 2);
         if (prefix !== table) {
-            throw new Error("Invalid prefixed column: '".concat(column, "'. Expected prefix '").concat(table, ".'"));
+            throw new Error(`Invalid prefixed column: '${column}'. Expected prefix '${table}.'`);
         }
         return col;
-    };
-    PostQueryBuilder.prototype.build = function (table) {
-        var _this = this;
-        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 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);
+    }
+    build(table) {
+        const verb = C6C.REPLACE in this.request ? C6C.REPLACE : C6C.INSERT;
+        const body = verb in this.request ? this.request[verb] : this.request;
+        const keys = Object.keys(body);
+        const params = [];
+        const placeholders = [];
+        for (const key of keys) {
+            const value = body[key];
+            const placeholder = this.addParam(params, key, value);
             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        )");
+        let sql = `${verb} INTO \`${table}\` (
+            ${keys.map(k => `\`${this.trimTablePrefix(table, k)}\``).join(', ')}
+         ) VALUES (
+            ${placeholders.join(', ')}
+        )`;
         if (C6C.UPDATE in this.request) {
-            var updateData = this.request[C6C.UPDATE];
+            const updateData = this.request[C6C.UPDATE];
             if (!Array.isArray(updateData)) {
-                throw new Error("Update data must be an array of keys to update, got: ".concat(JSON.stringify(updateData)));
+                throw new Error(`Update data must be an array of keys to update, got: ${JSON.stringify(updateData)}`);
             }
-            var updateClause = updateData.map(function (k) { return "`".concat(k, "` = VALUES(`").concat(k, "`)"); }).join(', ');
-            sql += " ON DUPLICATE KEY UPDATE ".concat(updateClause);
+            const updateClause = updateData.map(k => `\`${k}\` = VALUES(\`${k}\`)`).join(', ');
+            sql += ` ON DUPLICATE KEY UPDATE ${updateClause}`;
         }
-        return { sql: sql, params: params };
-    };
-    return PostQueryBuilder;
-}(ConditionBuilder));
-
-var PaginationBuilder = /** @class */ (function (_super) {
-    __extends(PaginationBuilder, _super);
-    function PaginationBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        return { sql, params };
     }
+}
+
+class PaginationBuilder extends JoinBuilder {
     /**
      * MySQL ORDER/LIMIT/OFFSET generator.
      *
@@ -1543,60 +1445,49 @@ var PaginationBuilder = /** @class */ (function (_super) {
      * }
      * ```
      */
-    PaginationBuilder.prototype.buildPaginationClause = function (pagination) {
-        var _this = this;
-        var _a;
-        var sql = "";
+    buildPaginationClause(pagination) {
+        let sql = "";
         /* -------- ORDER BY -------- */
-        if (pagination === null || pagination === void 0 ? void 0 : pagination[C6Constants.ORDER]) {
-            var orderParts = [];
-            for (var _i = 0, _b = Object.entries(pagination[C6Constants.ORDER]); _i < _b.length; _i++) {
-                var _c = _b[_i], key = _c[0], val = _c[1];
+        if (pagination?.[C6Constants.ORDER]) {
+            const orderParts = [];
+            for (const [key, val] of Object.entries(pagination[C6Constants.ORDER])) {
                 // FUNCTION CALL: val is an array of args
                 if (Array.isArray(val)) {
-                    var args = val
-                        .map(function (arg) { return Array.isArray(arg) ? _this.buildAggregateField(arg) : String(arg); })
+                    const args = val
+                        .map((arg) => Array.isArray(arg) ? this.buildAggregateField(arg) : String(arg))
                         .join(", ");
-                    orderParts.push("".concat(key, "(").concat(args, ")"));
+                    orderParts.push(`${key}(${args})`);
                 }
                 // SIMPLE COLUMN + DIR (ASC/DESC)
                 else {
-                    orderParts.push("".concat(key, " ").concat(String(val).toUpperCase()));
+                    orderParts.push(`${key} ${String(val).toUpperCase()}`);
                 }
             }
             if (orderParts.length)
-                sql += " ORDER BY ".concat(orderParts.join(", "));
+                sql += ` ORDER BY ${orderParts.join(", ")}`;
         }
         /* -------- LIMIT / OFFSET -------- */
-        if ((pagination === null || pagination === void 0 ? void 0 : pagination[C6Constants.LIMIT]) != null) {
-            var lim = parseInt(pagination[C6Constants.LIMIT], 10);
-            var page = parseInt((_a = pagination[C6Constants.PAGE]) !== null && _a !== void 0 ? _a : 1, 10);
-            var offset = (page - 1) * lim;
-            sql += " LIMIT ".concat(offset, ", ").concat(lim);
+        if (pagination?.[C6Constants.LIMIT] != null) {
+            const lim = parseInt(pagination[C6Constants.LIMIT], 10);
+            const page = parseInt(pagination[C6Constants.PAGE] ?? 1, 10);
+            const offset = (page - 1) * lim;
+            sql += ` LIMIT ${offset}, ${lim}`;
         }
-        this.config.verbose && console.log("[PAGINATION] ".concat(sql.trim()));
+        this.config.verbose && console.log(`[PAGINATION] ${sql.trim()}`);
         return sql;
-    };
-    return PaginationBuilder;
-}(JoinBuilder));
-
-var SelectQueryBuilder = /** @class */ (function (_super) {
-    __extends(SelectQueryBuilder, _super);
-    function SelectQueryBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
-    SelectQueryBuilder.prototype.build = function (table, isSubSelect) {
-        var _this = this;
-        var _a;
-        if (isSubSelect === void 0) { isSubSelect = false; }
-        var args = this.request;
+}
+
+class SelectQueryBuilder extends PaginationBuilder {
+    build(table, isSubSelect = false) {
+        const args = this.request;
         this.initAlias(table, args.JOIN);
-        var params = this.useNamedParams ? {} : [];
-        var selectList = (_a = args.SELECT) !== null && _a !== void 0 ? _a : ['*'];
-        var selectFields = selectList
-            .map(function (f) { return _this.buildAggregateField(f); })
+        const params = this.useNamedParams ? {} : [];
+        const selectList = args.SELECT ?? ['*'];
+        const selectFields = selectList
+            .map((f) => this.buildAggregateField(f))
             .join(', ');
-        var sql = "SELECT ".concat(selectFields, " FROM `").concat(table, "`");
+        let sql = `SELECT ${selectFields} FROM \`${table}\``;
         if (args.JOIN) {
             sql += this.buildJoinClauses(args.JOIN, params);
         }
@@ -1604,227 +1495,165 @@ var SelectQueryBuilder = /** @class */ (function (_super) {
             sql += this.buildWhereClause(args.WHERE, params);
         }
         if (args.GROUP_BY) {
-            var groupBy = Array.isArray(args.GROUP_BY)
+            const groupBy = Array.isArray(args.GROUP_BY)
                 ? args.GROUP_BY.join(', ')
                 : args.GROUP_BY;
-            sql += " GROUP BY ".concat(groupBy);
+            sql += ` GROUP BY ${groupBy}`;
         }
         if (args.HAVING) {
-            sql += " HAVING ".concat(this.buildBooleanJoinedConditions(args.HAVING, true, params));
+            sql += ` HAVING ${this.buildBooleanJoinedConditions(args.HAVING, true, params)}`;
         }
         if (args.PAGINATION) {
             sql += this.buildPaginationClause(args.PAGINATION);
         }
         else if (!isSubSelect) {
-            sql += " LIMIT 100";
+            sql += ` LIMIT 100`;
         }
-        console.log("[SELECT] ".concat(sql.trim()));
-        return { sql: sql, params: params };
-    };
-    return SelectQueryBuilder;
-}(PaginationBuilder));
-
-var UpdateQueryBuilder = /** @class */ (function (_super) {
-    __extends(UpdateQueryBuilder, _super);
-    function UpdateQueryBuilder() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        console.log(`[SELECT] ${sql.trim()}`);
+        return { sql, params };
     }
-    UpdateQueryBuilder.prototype.build = function (table) {
-        var _this = this;
-        var args = this.request;
-        var params = this.useNamedParams ? {} : [];
+}
+
+class UpdateQueryBuilder extends PaginationBuilder {
+    build(table) {
+        const args = this.request;
+        const params = this.useNamedParams ? {} : [];
         this.initAlias(table, args.JOIN);
-        var sql = "UPDATE `".concat(table, "`");
+        let sql = `UPDATE \`${table}\``;
         if (args.JOIN) {
             sql += this.buildJoinClauses(args.JOIN, params);
         }
         if (!(C6C.UPDATE in this.request)) {
             throw new Error("No update data provided in the request.");
         }
-        var setClauses = Object.entries(this.request[C6C.UPDATE]).map(function (_a) {
-            var col = _a[0], val = _a[1];
-            return _this.addParam(params, col, val);
-        });
-        sql += " SET ".concat(setClauses.join(', '));
+        const setClauses = Object.entries(this.request[C6C.UPDATE]).map(([col, val]) => this.addParam(params, col, val));
+        sql += ` SET ${setClauses.join(', ')}`;
         if (args.WHERE) {
             sql += this.buildWhereClause(args.WHERE, params);
         }
         if (args.PAGINATION) {
             sql += this.buildPaginationClause(args.PAGINATION);
         }
-        return { sql: sql, params: params };
-    };
-    return UpdateQueryBuilder;
-}(PaginationBuilder));
+        return { sql, params };
+    }
+}
 
-var SqlExecutor = /** @class */ (function (_super) {
-    __extends(SqlExecutor, _super);
-    function SqlExecutor() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.serialize = function (row) { return Object.fromEntries(Object.entries(row).map(function (_a) {
-            var k = _a[0], v = _a[1];
-            return [k, Buffer$1.isBuffer(v) ? v.toString('hex').toUpperCase() : v];
-        })); };
-        return _this;
+class SqlExecutor extends Executor {
+    async execute() {
+        const { TABLE_NAME } = this.config.restModel;
+        const method = this.config.requestMethod;
+        this.config.verbose && console.log(`[SQL EXECUTOR] ▶️ Executing ${method} on table "${TABLE_NAME}"`);
+        this.config.verbose && console.log(`[SQL EXECUTOR] 🧩 Request:`, JSON.stringify(this.request, undefined, 2));
+        switch (method) {
+            case 'GET': {
+                const rest = await this.runQuery();
+                return rest;
+            }
+            case 'POST': {
+                const result = await this.runQuery();
+                return result;
+            }
+            case 'PUT': {
+                const result = await this.runQuery();
+                return result;
+            }
+            case 'DELETE': {
+                const result = await this.runQuery();
+                return result;
+            }
+            default:
+                throw new Error(`Unsupported request method: ${method}`);
+        }
     }
-    SqlExecutor.prototype.execute = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var TABLE_NAME, method, _a, rest, result, result, result;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        TABLE_NAME = this.config.restModel.TABLE_NAME;
-                        method = this.config.requestMethod;
-                        this.config.verbose && console.log("[SQL EXECUTOR] \u25B6\uFE0F Executing ".concat(method, " on table \"").concat(TABLE_NAME, "\""));
-                        this.config.verbose && console.log("[SQL EXECUTOR] \uD83E\uDDE9 Request:", JSON.stringify(this.request, undefined, 2));
-                        _a = method;
-                        switch (_a) {
-                            case 'GET': return [3 /*break*/, 1];
-                            case 'POST': return [3 /*break*/, 3];
-                            case 'PUT': return [3 /*break*/, 5];
-                            case 'DELETE': return [3 /*break*/, 7];
-                        }
-                        return [3 /*break*/, 9];
-                    case 1: return [4 /*yield*/, this.runQuery()];
-                    case 2:
-                        rest = _b.sent();
-                        return [2 /*return*/, rest];
-                    case 3: return [4 /*yield*/, this.runQuery()];
-                    case 4:
-                        result = _b.sent();
-                        return [2 /*return*/, result];
-                    case 5: return [4 /*yield*/, this.runQuery()];
-                    case 6:
-                        result = _b.sent();
-                        return [2 /*return*/, result];
-                    case 7: return [4 /*yield*/, this.runQuery()];
-                    case 8:
-                        result = _b.sent();
-                        return [2 /*return*/, result];
-                    case 9: throw new Error("Unsupported request method: ".concat(method));
-                }
-            });
-        });
-    };
-    SqlExecutor.prototype.withConnection = function (cb) {
-        return __awaiter(this, void 0, void 0, function () {
-            var conn;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        console.log("[SQL EXECUTOR] \uD83D\uDCE1 Getting DB connection");
-                        return [4 /*yield*/, this.config.mysqlPool.getConnection()];
-                    case 1:
-                        conn = _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, , 4, 5]);
-                        this.config.verbose && console.log("[SQL EXECUTOR] \u2705 Connection acquired");
-                        return [4 /*yield*/, cb(conn)];
-                    case 3: return [2 /*return*/, _a.sent()];
-                    case 4:
-                        this.config.verbose && console.log("[SQL EXECUTOR] \uD83D\uDD0C Releasing DB connection");
-                        conn.release();
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SqlExecutor.prototype.formatSQLWithParams = function (sql, params) {
-        var _this = this;
+    async withConnection(cb) {
+        console.log(`[SQL EXECUTOR] 📡 Getting DB connection`);
+        const conn = await this.config.mysqlPool.getConnection();
+        try {
+            this.config.verbose && console.log(`[SQL EXECUTOR] ✅ Connection acquired`);
+            return await cb(conn);
+        }
+        finally {
+            this.config.verbose && console.log(`[SQL EXECUTOR] 🔌 Releasing DB connection`);
+            conn.release();
+        }
+    }
+    serialize = (row) => Object.fromEntries(Object.entries(row).map(([k, v]) => [k, Buffer$1.isBuffer(v) ? v.toString('hex').toUpperCase() : v]));
+    formatSQLWithParams(sql, params) {
         if (Array.isArray(params)) {
-            var index_1 = 0;
-            return sql.replace(/\?/g, function () {
-                if (index_1 >= params.length)
+            let index = 0;
+            return sql.replace(/\?/g, () => {
+                if (index >= params.length)
                     return '?';
-                var val = params[index_1++];
-                return _this.formatValue(val);
+                const val = params[index++];
+                return this.formatValue(val);
             });
         }
         else {
-            return sql.replace(/:([a-zA-Z0-9_]+)/g, function (_, key) {
-                var val = params[key];
-                return _this.formatValue(val);
+            return sql.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+                const val = params[key];
+                return this.formatValue(val);
             });
         }
-    };
-    SqlExecutor.prototype.formatValue = function (val) {
+    }
+    formatValue(val) {
         if (val === null || val === undefined)
             return 'NULL';
         if (Buffer$1.isBuffer(val))
-            return "UNHEX('".concat(val.toString('hex'), "')");
+            return `UNHEX('${val.toString('hex')}')`;
         if (typeof val === 'string')
-            return "'".concat(val.replace(/'/g, "''"), "'");
+            return `'${val.replace(/'/g, "''")}'`;
         if (typeof val === 'number')
             return val.toString();
         if (val instanceof Date)
-            return "'".concat(val.toISOString().slice(0, 19).replace('T', ' '), "'");
-        return "'".concat(JSON.stringify(val), "'");
-    };
-    SqlExecutor.prototype.runQuery = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var TABLE_NAME, method, builder, QueryResult, formatted, toUnnamed, _a, sql, values;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        TABLE_NAME = this.config.restModel.TABLE_NAME;
-                        method = this.config.requestMethod;
-                        switch (method) {
-                            case 'GET':
-                                builder = new SelectQueryBuilder(this.config, this.request);
-                                break;
-                            case 'PUT':
-                                builder = new UpdateQueryBuilder(this.config, this.request);
-                                break;
-                            case 'DELETE':
-                                builder = new DeleteQueryBuilder(this.config, this.request);
-                                break;
-                            case 'POST':
-                                builder = new PostQueryBuilder(this.config, this.request);
-                                break;
-                            default:
-                                throw new Error("Unsupported query method: ".concat(method));
-                        }
-                        QueryResult = builder.build(TABLE_NAME);
-                        this.config.verbose && console.log("[SQL EXECUTOR] \uD83E\uDDE0 Generated ".concat(method.toUpperCase(), " SQL:"), QueryResult);
-                        formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
-                        this.config.verbose && console.log("[SQL EXECUTOR] \uD83E\uDDE0 Formatted ".concat(method.toUpperCase(), " SQL:"), formatted);
-                        toUnnamed = namedPlaceholders();
-                        _a = toUnnamed(QueryResult.sql, QueryResult.params), sql = _a[0], values = _a[1];
-                        return [4 /*yield*/, this.withConnection(function (conn) { return __awaiter(_this, void 0, void 0, function () {
-                                var result;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, conn.query(sql, values)];
-                                        case 1:
-                                            result = (_a.sent())[0];
-                                            if (method === 'GET') {
-                                                this.config.verbose && console.log("[SQL EXECUTOR] \uD83D\uDCE6 Rows fetched:", result);
-                                                return [2 /*return*/, {
-                                                        rest: result.map(this.serialize),
-                                                        sql: { sql: sql, values: values }
-                                                    }];
-                                            }
-                                            else {
-                                                this.config.verbose && console.log("[SQL EXECUTOR] \u270F\uFE0F Rows affected:", result.affectedRows);
-                                                return [2 /*return*/, {
-                                                        affected: result.affectedRows,
-                                                        rest: [],
-                                                        sql: { sql: sql, values: values }
-                                                    }];
-                                            }
-                                    }
-                                });
-                            }); })];
-                    case 1: return [2 /*return*/, _b.sent()];
-                }
-            });
+            return `'${val.toISOString().slice(0, 19).replace('T', ' ')}'`;
+        return `'${JSON.stringify(val)}'`;
+    }
+    async runQuery() {
+        const { TABLE_NAME } = this.config.restModel;
+        const method = this.config.requestMethod;
+        let builder;
+        switch (method) {
+            case 'GET':
+                builder = new SelectQueryBuilder(this.config, this.request);
+                break;
+            case 'PUT':
+                builder = new UpdateQueryBuilder(this.config, this.request);
+                break;
+            case 'DELETE':
+                builder = new DeleteQueryBuilder(this.config, this.request);
+                break;
+            case 'POST':
+                builder = new PostQueryBuilder(this.config, this.request);
+                break;
+            default:
+                throw new Error(`Unsupported query method: ${method}`);
+        }
+        const QueryResult = builder.build(TABLE_NAME);
+        this.config.verbose && console.log(`[SQL EXECUTOR] 🧠 Generated ${method.toUpperCase()} SQL:`, QueryResult);
+        const formatted = this.formatSQLWithParams(QueryResult.sql, QueryResult.params);
+        this.config.verbose && console.log(`[SQL EXECUTOR] 🧠 Formatted ${method.toUpperCase()} SQL:`, formatted);
+        const toUnnamed = namedPlaceholders();
+        const [sql, values] = toUnnamed(QueryResult.sql, QueryResult.params);
+        return await this.withConnection(async (conn) => {
+            const [result] = await conn.query(sql, values);
+            if (method === 'GET') {
+                this.config.verbose && console.log(`[SQL EXECUTOR] 📦 Rows fetched:`, result);
+                return {
+                    rest: result.map(this.serialize),
+                    sql: { sql, values }
+                };
+            }
+            else {
+                this.config.verbose && console.log(`[SQL EXECUTOR] ✏️ Rows affected:`, result.affectedRows);
+                return {
+                    affected: result.affectedRows,
+                    rest: [],
+                    sql: { sql, values }
+                };
+            }
         });
-    };
-    return SqlExecutor;
-}(Executor));
+    }
+}
 
 var SqlExecutor$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1833,101 +1662,80 @@ var SqlExecutor$1 = /*#__PURE__*/Object.freeze({
 
 // TODO - WE MUST make this a generic - optional, but helpful
 // note sure how it would help anyone actually...
-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 method, table, primary, payload, primaryKeys, primaryKeyName, response, err_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    method = req.method.toUpperCase();
-                    table = req.params.table;
-                    primary = req.params.primary;
-                    payload = method === 'GET' ? req.query : req.body;
-                    if (!(table in C6.TABLES)) {
-                        res.status(400).json({ error: "Invalid table: ".concat(table) });
-                        return [2 /*return*/];
+function ExpressHandler({ C6, mysqlPool }) {
+    return async (req, res, next) => {
+        try {
+            const method = req.method.toUpperCase();
+            const table = req.params.table;
+            const primary = req.params.primary;
+            const payload = method === 'GET' ? req.query : req.body;
+            if (!(table in C6.TABLES)) {
+                res.status(400).json({ error: `Invalid table: ${table}` });
+                return;
+            }
+            const primaryKeys = C6.TABLES[table].PRIMARY;
+            if (primary && primaryKeys.length !== 1) {
+                if (primaryKeys.length > 1) {
+                    res.status(400).json({ error: `Table ${table} has multiple primary keys. Cannot implicitly determine key.` });
+                    return;
+                }
+                res.status(400).json({
+                    error: `Table ${table} has no primary keys. Please specify one.`
+                });
+                return;
+            }
+            const primaryKeyName = primaryKeys[0];
+            // 👇 Call restRequest for the resolved method
+            // TODO - add primary conditionally based on method signature
+            switch (method) {
+                case 'GET':
+                    if (primary) {
+                        payload[C6C.WHERE][primaryKeyName] = primary;
                     }
-                    primaryKeys = C6.TABLES[table].PRIMARY;
-                    if (primary && primaryKeys.length !== 1) {
-                        if (primaryKeys.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*/];
+                    break;
+                case 'PUT':
+                case 'DELETE':
+                    if (primary) {
+                        payload[C6C.WHERE][primaryKeyName] = primary;
                     }
-                    primaryKeyName = primaryKeys[0];
-                    // 👇 Call restRequest for the resolved method
-                    // TODO - add primary conditionally based on method signature
-                    switch (method) {
-                        case 'GET':
-                            if (primary) {
-                                payload[C6C.WHERE][primaryKeyName] = primary;
-                            }
-                            break;
-                        case 'PUT':
-                        case 'DELETE':
-                            if (primary) {
-                                payload[C6C.WHERE][primaryKeyName] = primary;
-                            }
-                            else {
-                                res.status(400).json({ error: "Invalid request: ".concat(method, " requires a primary key.") });
-                            }
-                            break;
-                        case 'POST':
-                            break;
-                        default:
-                            res.status(405).json({ error: "Method ".concat(method, " not allowed") });
-                            return [2 /*return*/];
+                    else {
+                        res.status(400).json({ error: `Invalid request: ${method} requires a primary key.` });
                     }
-                    return [4 /*yield*/, restRequest({
-                            C6: C6,
-                            mysqlPool: mysqlPool,
-                            requestMethod: method,
-                            restModel: C6.TABLES[table]
-                        })(payload)];
-                case 1:
-                    response = _a.sent();
-                    res.status(200).json(__assign({ success: true }, response));
-                    return [3 /*break*/, 3];
-                case 2:
-                    err_1 = _a.sent();
-                    res.status(500).json({ success: false, error: err_1 });
-                    next(err_1);
-                    return [3 /*break*/, 3];
-                case 3: return [2 /*return*/];
+                    break;
+                case 'POST':
+                    break;
+                default:
+                    res.status(405).json({ error: `Method ${method} not allowed` });
+                    return;
             }
-        });
-    }); };
+            const response = await restRequest({
+                C6,
+                mysqlPool,
+                requestMethod: method,
+                restModel: C6.TABLES[table]
+            })(payload);
+            res.status(200).json({ success: true, ...response });
+        }
+        catch (err) {
+            res.status(500).json({ success: false, error: err });
+            next(err);
+        }
+    };
 }
 
 // Alias a table name with a given alias
-var A = function (tableName, alias) {
-    return "".concat(tableName, " ").concat(alias);
-};
+const A = (tableName, alias) => `${tableName} ${alias}`;
 // Qualify a column constant (e.g. 'property_units.parcel_id') to an alias
-var F = function (qualifiedCol, alias) {
-    return "".concat(alias, ".").concat(qualifiedCol.split('.').pop());
-};
+const F = (qualifiedCol, alias) => `${alias}.${qualifiedCol.split('.').pop()}`;
 // Equal join condition using full-qualified column constants
-var fieldEq = function (leftCol, rightCol, leftAlias, rightAlias) {
-    var _a;
-    return (_a = {},
-        _a[F(leftCol, leftAlias)] = F(rightCol, rightAlias),
-        _a);
-};
+const fieldEq = (leftCol, rightCol, leftAlias, rightAlias) => ({
+    [F(leftCol, leftAlias)]: F(rightCol, rightAlias)
+});
 // ST_Distance_Sphere for aliased fields
-var distSphere = function (fromCol, toCol, fromAlias, toAlias) {
-    return [C6C.ST_DISTANCE_SPHERE, F(fromCol, fromAlias), F(toCol, toAlias)];
-};
+const distSphere = (fromCol, toCol, fromAlias, toAlias) => [C6C.ST_DISTANCE_SPHERE, F(fromCol, fromAlias), F(toCol, toAlias)];
 
 function determineRuntimeJsType(mysqlType) {
-    var base = mysqlType.toLowerCase().split('(')[0];
+    const base = mysqlType.toLowerCase().split('(')[0];
     if ([
         'binary', 'varbinary', 'blob', 'tinyblob', 'mediumblob', 'longblob'
     ].includes(base))
@@ -1948,23 +1756,15 @@ function determineRuntimeJsType(mysqlType) {
     return 'string';
 }
 function getPrimaryKeyTypes(table) {
-    var _a;
-    var result = {};
-    var _loop_1 = function (key) {
-        var fullKey = (_a = Object.entries(table.COLUMNS).find(function (_a) {
-            _a[0]; var short = _a[1];
-            return short === key;
-        })) === null || _a === void 0 ? void 0 : _a[0];
+    const result = {};
+    for (const key of table.PRIMARY_SHORT) {
+        const fullKey = Object.entries(table.COLUMNS).find(([_, short]) => short === key)?.[0];
         if (typeof fullKey === 'string') {
-            var validation = table.TYPE_VALIDATION[fullKey];
+            const validation = table.TYPE_VALIDATION[fullKey];
             if (!validation)
-                return "continue";
+                continue;
             result[key] = determineRuntimeJsType(validation.MYSQL_TYPE);
         }
-    };
-    for (var _i = 0, _b = table.PRIMARY_SHORT; _i < _b.length; _i++) {
-        var key = _b[_i];
-        _loop_1(key);
     }
     return result;
 }
@@ -1973,42 +1773,30 @@ function getPrimaryKeyTypes(table) {
  * Conditionally group a log if verbose.
  */
 function group(title, data) {
-    console.groupCollapsed("%c".concat(title), "color: #007acc");
+    console.groupCollapsed(`%c${title}`, "color: #007acc");
     if (data !== undefined)
         console.log(data);
     console.groupEnd();
 }
-function info(message) {
-    var optional = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        optional[_i - 1] = arguments[_i];
-    }
-    console.info.apply(console, __spreadArray(["%cINFO: ".concat(message), "color: #0a0"], optional, false));
+function info(message, ...optional) {
+    console.info(`%cINFO: ${message}`, "color: #0a0", ...optional);
 }
-function warn(message) {
-    var optional = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        optional[_i - 1] = arguments[_i];
-    }
-    console.warn.apply(console, __spreadArray(["%cWARN: ".concat(message), "color: #e90"], optional, false));
+function warn(message, ...optional) {
+    console.warn(`%cWARN: ${message}`, "color: #e90", ...optional);
 }
-function error(message) {
-    var optional = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        optional[_i - 1] = arguments[_i];
-    }
-    console.error.apply(console, __spreadArray(["%cERROR: ".concat(message), "color: #c00"], optional, false));
+function error(message, ...optional) {
+    console.error(`%cERROR: ${message}`, "color: #c00", ...optional);
 }
 
 function checkAllRequestsComplete() {
-    var stillRunning = apiRequestCache.filter(function (cache) { return undefined === cache.response; });
+    const stillRunning = apiRequestCache.filter((cache) => 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) + ')');
         }
         // when requests return emtpy sets in full renders, it may not be possible to track their progress.
         console.warn('stillRunning...', stillRunning);
-        return stillRunning.map(function (cache) { return cache.requestArgumentsSerialized; });
+        return stillRunning.map((cache) => cache.requestArgumentsSerialized);
     }
     return true;
 }
@@ -2021,7 +1809,7 @@ function onError(message) {
 }
 
 function isVerbose () {
-    var envVerbose = getEnvVar('VERBOSE') || getEnvVar('REACT_APP_VERBOSE') || getEnvVar('VITE_VERBOSE') || '';
+    const envVerbose = getEnvVar('VERBOSE') || getEnvVar('REACT_APP_VERBOSE') || getEnvVar('VITE_VERBOSE') || '';
     return ['true', '1', 'yes', 'on'].includes(envVerbose.toLowerCase());
 }