@carbonorm/carbonnode 3.5.9 → 3.6.0

package/dist/index.esm.js

@@ -1,10 +1,11 @@
 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';
 
-const C6Constants = {
+var C6Constants = {
     // try to 1=1 match the Rest abstract class
     ADDDATE: 'ADDDATE',
     ADDTIME: 'ADDTIME',
@@ -162,7 +163,7 @@ const C6Constants = {
     FINISH: 'FINISH',
     VALIDATE_C6_ENTITY_ID_REGEX: '#^([a-fA-F0-9]{20,35})$#',
 };
-const C6C = C6Constants;
+var C6C = C6Constants;
 
 // @link https://www.npmjs.com/package/axios-cache-adapter
 // updating these values
@@ -267,100 +268,109 @@ var axiosInstance = (axios.create({
     */
 }));
 
-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);
+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; });
         if (!tableDefinition) {
-            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.`);
+            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."));
         }
         return tableDefinition;
     });
-    for (const tableDefinition of tableDefinitions) {
-        for (const value of Object.keys(restfulObject)) {
-            const shortReference = value.toUpperCase();
+    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();
             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)) {
-                // TODO - pretty sure we could validate this better on the FED
-                const val = restfulObject[value];
-                if (Array.isArray(val)) {
-                    payload[value] = val.sort();
+                var val_1 = restfulObject[value];
+                if (Array.isArray(val_1)) {
+                    payload[value] = val_1.sort();
                 }
-                else if (typeof val === 'object' && val !== null) {
-                    payload[value] = Object.keys(val)
+                else if (typeof val_1 === 'object' && val_1 !== null) {
+                    payload[value] = Object.keys(val_1)
                         .sort()
-                        .reduce((acc, key) => ({ ...acc, [key]: val[key] }), {});
+                        .reduce(function (acc, key) {
+                        var _a;
+                        return (__assign(__assign({}, acc), (_a = {}, _a[key] = val_1[key], _a)));
+                    }, {});
                 }
-                continue;
+                return "continue";
             }
             if (shortReference in tableDefinition) {
-                const longName = tableDefinition[shortReference];
-                const columnValue = restfulObject[value];
+                var longName = tableDefinition[shortReference];
+                var columnValue = restfulObject[value];
                 payload[longName] = columnValue;
-                const regexValidations = tableDefinition.REGEX_VALIDATION[longName];
+                var regexValidations = tableDefinition.REGEX_VALIDATION[longName];
                 if (regexValidations instanceof RegExp) {
                     if (!regexValidations.test(columnValue)) {
-                        regexErrorHandler(`Failed to match regex (${regexValidations}) for column (${longName})`);
-                        throw new Error(`Failed to match regex (${regexValidations}) for column (${longName})`);
+                        regexErrorHandler("Failed to match regex (".concat(regexValidations, ") for column (").concat(longName, ")"));
+                        throw new Error("Failed to match regex (".concat(regexValidations, ") for column (").concat(longName, ")"));
                     }
                 }
                 else if (typeof regexValidations === 'object' && regexValidations !== null) {
-                    for (const errorMessage in regexValidations) {
-                        const regex = regexValidations[errorMessage];
+                    for (var errorMessage in regexValidations) {
+                        var regex = regexValidations[errorMessage];
                         if (!regex.test(columnValue)) {
-                            const devErrorMessage = `Failed to match regex (${regex}) for column (${longName})`;
+                            var devErrorMessage = "Failed to match regex (".concat(regex, ") for column (").concat(longName, ")");
                             regexErrorHandler(errorMessage || devErrorMessage);
                             throw new Error(devErrorMessage);
                         }
                     }
                 }
             }
-            else if (value in Object.values(tableDefinition.COLUMNS)) {
+            else if (Object.values(tableDefinition.COLUMNS).includes(value)) {
                 // Already a fully qualified column name
-                const columnValue = restfulObject[value];
+                var columnValue = restfulObject[value];
                 payload[value] = columnValue;
-                const regexValidations = tableDefinition.REGEX_VALIDATION[value];
+                var 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})`);
+                        regexErrorHandler("Failed to match regex (".concat(regexValidations, ") for column (").concat(value, ")"));
+                        throw new Error("Failed to match regex (".concat(regexValidations, ") for column (").concat(value, ")"));
                     }
                 }
                 else if (typeof regexValidations === 'object' && regexValidations !== null) {
-                    for (const errorMessage in regexValidations) {
-                        const regex = regexValidations[errorMessage];
+                    for (var errorMessage in regexValidations) {
+                        var regex = regexValidations[errorMessage];
                         if (!regex.test(columnValue)) {
-                            const devErrorMessage = `Failed to match regex (${regex}) for column (${value})`;
+                            var devErrorMessage = "Failed to match regex (".concat(regex, ") for column (").concat(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((acc, key) => ({ ...acc, [key]: payload[key] }), {});
+        .reduce(function (acc, key) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[key] = payload[key], _a)));
+    }, {});
 }
 
-const isNode = () => {
+var isNode = function () {
+    var _a;
     console.log('Checking if running in Node.js environment...');
-    const isNodeEnv = typeof process !== 'undefined' && !!process.versions?.node;
-    console.log(`Is Node.js environment: ${isNodeEnv}`);
+    var isNodeEnv = typeof process !== 'undefined' && !!((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
+    console.log("Is Node.js environment: ".concat(isNodeEnv));
     return isNodeEnv;
 };
 
@@ -368,94 +378,112 @@ const isNode = () => {
  * Facade: routes API calls to SQL or HTTP executors based on runtime context.
  */
 function restRequest(configX) {
-    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();
-    };
+    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()];
+            }
+        });
+    }); };
 }
 
 function restOrm(configFn) {
     return {
-        Get: restRequest(() => ({
-            ...configFn(),
-            requestMethod: "GET"
-        })),
-        Put: restRequest(() => ({
-            ...configFn(),
-            requestMethod: "PUT"
-        })),
-        Post: restRequest(() => ({
-            ...configFn(),
-            requestMethod: "POST"
-        })),
-        Delete: restRequest(() => ({
-            ...configFn(),
-            requestMethod: "DELETE"
-        }))
+        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" })); })
     };
 }
 
-function timeout(shouldContinueAfterTimeout, cb, timeoutMs = 3000) {
-    const timer = () => setTimeout(() => {
+function timeout(shouldContinueAfterTimeout, cb, timeoutMs) {
+    if (timeoutMs === void 0) { timeoutMs = 3000; }
+    var timer = function () { return setTimeout(function () {
         if (false === shouldContinueAfterTimeout()) {
             return;
         }
         cb();
-    }, timeoutMs);
-    const timerId = timer();
-    return () => {
+    }, timeoutMs); };
+    var timerId = timer();
+    return function () {
         clearTimeout(timerId);
     };
 }
 
-class Executor {
-    config;
-    request;
-    useNamedParams;
-    constructor(config, request, useNamedParams = false) {
+var Executor = /** @class */ (function () {
+    function Executor(config, request, useNamedParams) {
+        if (useNamedParams === void 0) { useNamedParams = false; }
         this.config = config;
         this.request = request;
         this.useNamedParams = useNamedParams;
     }
-    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();
-                }
-                try {
-                    // todo - this
-                    await fn(args);
-                }
-                catch (err) {
-                    console.error(`[LIFECYCLE ERROR] ${this.config.requestMethod}.${String(phase)}:${key}`, err);
-                    throw err;
+    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*/];
                 }
-            }
-        }
-    }
-}
+            });
+        });
+    };
+    return Executor;
+}());
 
-function getEnvVar(key, fallback = '') {
+function getEnvVar(key, fallback) {
+    if (fallback === void 0) { fallback = ''; }
     // Vite-style injection
     // @ts-ignore
     if (typeof import.meta !== 'undefined' && import.meta.env && key in import.meta.env) {
@@ -492,12 +520,12 @@ var eFetchDependencies;
 })(eFetchDependencies || (eFetchDependencies = {}));
 
 // Refined TypeScript types for CarbonORM
-const POST = 'POST';
-const PUT = 'PUT';
-const GET = 'GET';
-const DELETE = 'DELETE';
+var POST = 'POST';
+var PUT = 'PUT';
+var GET = 'GET';
+var DELETE = 'DELETE';
 
-const toastOptions = {
+var toastOptions = {
     position: "bottom-left",
     autoClose: 10000,
     hideProgressBar: false,
@@ -506,7 +534,7 @@ const toastOptions = {
     draggable: true,
     theme: "dark",
 };
-const toastOptionsDevs = {
+var toastOptionsDevs = {
     position: "bottom-right",
     autoClose: 3000,
     hideProgressBar: false,
@@ -518,19 +546,20 @@ const toastOptionsDevs = {
 
 // When we capture DropExceptions and display them as a custom page, this will change.
 function TestRestfulResponse(response, success, error) {
-    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;
+    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 (typeof successReturn === 'string') {
             toast.success(successReturn, toastOptions);
         }
         // this could end up with bad results for deleting id's === 0
-        return response.data.created ?? response.data.updated ?? response.data.deleted ?? true;
+        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;
     }
-    let errorReturn = 'function' === typeof error ? error?.(response) : error;
+    var errorReturn = 'function' === typeof error ? error === null || error === void 0 ? void 0 : error(response) : error;
     if (typeof errorReturn === 'string') {
         toast.error(errorReturn, toastOptions);
     }
@@ -543,15 +572,15 @@ function removePrefixIfExists(tableName, prefix) {
     return tableName;
 }
 function removeInvalidKeys(request, c6Tables) {
-    let intersection = {};
-    let restfulObjectKeys = [];
-    const tableList = Object.values(c6Tables);
-    tableList.forEach(table => Object.values(table.COLUMNS).forEach(column => {
+    var intersection = {};
+    var restfulObjectKeys = [];
+    var tableList = Object.values(c6Tables);
+    tableList.forEach(function (table) { return Object.values(table.COLUMNS).forEach(function (column) {
         if (false === restfulObjectKeys.includes(column)) {
             restfulObjectKeys.push(column);
         }
-    }));
-    Object.keys(request).forEach(key => {
+    }); });
+    Object.keys(request).forEach(function (key) {
         if (restfulObjectKeys.includes(key)) {
             intersection[key] = request[key];
         }
@@ -562,13 +591,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.
-let apiRequestCache = [];
-let userCustomClearCache = [];
+var apiRequestCache = [];
+var userCustomClearCache = [];
 function clearCache(props) {
-    if (false === props?.ignoreWarning) {
+    if (false === (props === null || props === void 0 ? void 0 : props.ignoreWarning)) {
         console.warn('The rest api clearCache should only be used with extreme care! Avoid using this in favor of using `cacheResults : boolean`.');
     }
-    userCustomClearCache.map((f) => 'function' === typeof f && f());
+    userCustomClearCache.map(function (f) { return 'function' === typeof f && f(); });
     userCustomClearCache = apiRequestCache = [];
 }
 function checkCache(cacheResult, requestMethod, tableName, request) {
@@ -583,551 +612,601 @@ function checkCache(cacheResult, requestMethod, tableName, request) {
 }
 
 function sortAndSerializeQueryObject(tables, query) {
-    const orderedQuery = Object.keys(query).sort().reduce((obj, key) => {
+    var orderedQuery = Object.keys(query).sort().reduce(function (obj, key) {
         obj[key] = query[key];
         return obj;
     }, {});
     return tables + ' ' + JSON.stringify(orderedQuery);
 }
 
-class HttpExecutor extends Executor {
-    putState(response, request, callback) {
-        this.config.reactBootstrap?.updateRestfulObjectArrays({
-            callback,
+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,
             dataOrCallback: [
-                removeInvalidKeys({
-                    ...request,
-                    ...response?.data?.rest,
-                }, this.config.C6.TABLES)
+                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)
             ],
             stateKey: this.config.restModel.TABLE_NAME,
             uniqueObjectId: this.config.restModel.PRIMARY_SHORT
         });
-    }
-    postState(response, request, callback) {
+    };
+    HttpExecutor.prototype.postState = function (response, request, callback) {
+        var _this = this;
+        var _a, _b, _c;
         if (1 !== this.config.restModel.PRIMARY_SHORT.length) {
             console.error("C6 received unexpected result's given the primary key length");
         }
         else {
-            const pk = this.config.restModel.PRIMARY_SHORT[0];
+            var 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] = response.data?.created;
+            request[pk] = (_a = response.data) === null || _a === void 0 ? void 0 : _a.created;
         }
-        this.config.reactBootstrap?.updateRestfulObjectArrays({
-            callback,
+        (_b = this.config.reactBootstrap) === null || _b === void 0 ? void 0 : _b.updateRestfulObjectArrays({
+            callback: callback,
             dataOrCallback: undefined !== request.dataInsertMultipleRows
-                ? request.dataInsertMultipleRows.map((request, index) => {
-                    return removeInvalidKeys({
-                        ...request,
-                        ...(index === 0 ? response?.data?.rest : {}),
-                    }, this.config.C6.TABLES);
+                ? 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);
                 })
                 : [
-                    removeInvalidKeys({
-                        ...request,
-                        ...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)
                 ],
             stateKey: this.config.restModel.TABLE_NAME,
             uniqueObjectId: this.config.restModel.PRIMARY_SHORT
         });
-    }
-    deleteState(_response, request, callback) {
-        this.config.reactBootstrap?.deleteRestfulObjectArrays({
-            callback,
+    };
+    HttpExecutor.prototype.deleteState = function (_response, request, callback) {
+        var _a;
+        (_a = this.config.reactBootstrap) === null || _a === void 0 ? void 0 : _a.deleteRestfulObjectArrays({
+            callback: callback,
             dataOrCallback: [
                 request,
             ],
             stateKey: this.config.restModel.TABLE_NAME,
             uniqueObjectId: this.config.restModel.PRIMARY_SHORT
         });
-    }
-    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) {
+    };
+    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(',');
                         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');
                         }
-                    }
-                    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);
+                        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 [2 /*return*/, null];
                         }
-                        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 = 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;
                         }
-                        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];
+                        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.');
                                                 }
-                                                return accumulator;
-                                            }, {}),
-                                            ...C6.TABLES[operatingTable].TABLE_REFERENCED_BY // it is unlikely that a C6 table will have any TABLE_REFERENCED_BY
+                                            }
+                                        }
+                                        // 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);
                                         }
-                                        : {},
-                                    ...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];
+                                        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
+                                            });
+                                            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
+                                                });
                                             }
-                                            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']);
+                                            // 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;
-                                    }, []).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;
+                                        catch (throwableError) {
+                                            if (isTest()) {
+                                                throw new Error(JSON.stringify(throwableError));
                                             }
-                                            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 = [];
+                                            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*/];
                                 }
-                                this.request.fetchDependencies.push(await promise);
                             });
-                        }
-                    }
-                    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 [4 /*yield*/, apiRequest()];
+                    case 2: return [2 /*return*/, _b.sent()];
                 }
-                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();
-    }
-}
+            });
+        });
+    };
+    return HttpExecutor;
+}(Executor));
 
 var HttpExecutor$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1144,188 +1223,221 @@ function convertHexIfBinary(_col, val, columnDef) {
     return val;
 }
 
-class AggregateBuilder extends Executor {
-    buildAggregateField(field) {
+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;
         if (typeof field === 'string') {
             return field;
         }
         if (!Array.isArray(field) || field.length === 0) {
             throw new Error('Invalid SELECT field entry');
         }
-        let [fn, ...args] = field;
-        let alias;
+        var fn = field[0], args = field.slice(1);
+        var alias;
         if (args.length >= 2 && String(args[args.length - 2]).toUpperCase() === 'AS') {
             alias = String(args.pop());
             args.pop();
         }
-        const F = String(fn).toUpperCase();
-        const argList = args.map(arg => Array.isArray(arg) ? this.buildAggregateField(arg) : arg).join(', ');
-        let expr = `${F}(${argList})`;
+        var F = String(fn).toUpperCase();
+        var argList = args.map(function (arg) {
+            return Array.isArray(arg) ? _this.buildAggregateField(arg) : arg;
+        }).join(', ');
+        var expr = "".concat(F, "(").concat(argList, ")");
         if (alias) {
-            expr += ` AS ${alias}`;
+            expr += " AS ".concat(alias);
         }
-        this.config.verbose && console.log(`[SELECT] ${expr}`);
+        this.config.verbose && console.log("[SELECT] ".concat(expr));
         return expr;
-    }
-}
+    };
+    return AggregateBuilder;
+}(Executor));
 
-class ConditionBuilder extends AggregateBuilder {
-    aliasMap = {};
-    initAlias(baseTable, joins) {
-        this.aliasMap = { [baseTable]: baseTable };
+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);
         if (!joins)
             return;
-        for (const joinType in joins) {
-            for (const raw in joins[joinType]) {
-                const [table, alias] = raw.split(' ');
+        for (var joinType in joins) {
+            for (var raw in joins[joinType]) {
+                var _b = raw.split(' '), table = _b[0], alias = _b[1];
                 this.aliasMap[alias || table] = table;
             }
         }
-    }
-    isColumnRef(ref) {
+    };
+    ConditionBuilder.prototype.isColumnRef = function (ref) {
+        var _a, _b;
         if (typeof ref !== 'string' || !ref.includes('.'))
             return false;
-        const [prefix, column] = ref.split('.', 2);
-        const tableName = this.aliasMap[prefix] || prefix;
-        const table = this.config.C6?.TABLES?.[tableName];
+        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];
         if (!table)
             return false;
-        const fullKey = `${tableName}.${column}`;
+        var fullKey = "".concat(tableName, ".").concat(column);
         if (table.COLUMNS && (fullKey in table.COLUMNS))
             return true;
-        if (table.COLUMNS && Object.values(table.COLUMNS).includes(ref))
+        if (table.COLUMNS && Object.values(table.COLUMNS).includes(column))
             return true;
-        this.config.verbose && console.log(`[COLUMN REF] ${ref} is not a valid column reference`);
         return false;
-    }
-    execute() {
+    };
+    ConditionBuilder.prototype.execute = function () {
         throw new Error("Method not implemented.");
-    }
-    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) {
+    };
+    ConditionBuilder.prototype.isTableReference = function (val) {
+        var _a, _b;
+        if (typeof val !== 'string' || !val.includes('.'))
+            return false;
+        var _c = val.split('.'), prefix = _c[0], column = _c[1];
+        var tableName = (_a = this.aliasMap[prefix]) !== null && _a !== void 0 ? _a : prefix;
+        return (typeof ((_b = this.config.C6) === null || _b === void 0 ? void 0 : _b.TABLES[tableName]) === 'object' &&
+            val in this.config.C6.TABLES[tableName].COLUMNS &&
+            this.config.C6.TABLES[tableName].COLUMNS[val] === column);
+    };
+    ConditionBuilder.prototype.validateOperator = function (op) {
         if (!this.OPERATORS.has(op)) {
-            throw new Error(`Invalid or unsupported SQL operator detected: '${op}'`);
+            throw new Error("Invalid or unsupported SQL operator detected: '".concat(op, "'"));
         }
-    }
-    addParam(params, column, value) {
-        const columnDef = this.config.C6[column.split('.')[0]]?.TYPE_VALIDATION?.[column];
-        const val = convertHexIfBinary(column, value, columnDef);
+    };
+    ConditionBuilder.prototype.addParam = function (params, column, value) {
+        var _a, _b;
+        var columnDef = (_b = (_a = this.config.C6[column.split('.')[0]]) === null || _a === void 0 ? void 0 : _a.TYPE_VALIDATION) === null || _b === void 0 ? void 0 : _b[column];
+        var val = convertHexIfBinary(column, value, columnDef);
         if (this.useNamedParams) {
-            const key = `param${Object.keys(params).length}`;
+            var key = "param".concat(Object.keys(params).length);
             params[key] = val;
-            return `:${key}`;
+            return ":".concat(key);
         }
         else {
             params.push(val);
             return '?';
         }
-    }
-    buildBooleanJoinedConditions(set, andMode = true, params = []) {
-        const booleanOperator = andMode ? 'AND' : 'OR';
-        const addCondition = (column, op, value) => {
+    };
+    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) {
             // 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) {
-                    const [col1, col2] = op;
-                    const threshold = Array.isArray(value) ? value[0] : value;
-                    return `ST_Distance_Sphere(${col1}, ${col2}) < ${this.addParam(params, '', threshold)}`;
+                    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 leftIsCol = this.isColumnRef(column);
-            const rightIsCol = typeof value === 'string' && this.isColumnRef(value);
+            var leftIsCol = _this.isColumnRef(column);
+            var leftIsRef = _this.isTableReference(column);
+            var rightIsCol = typeof value === 'string' && _this.isColumnRef(value);
             if (!leftIsCol && !rightIsCol) {
-                throw new Error(`Potential SQL injection detected: '${column} ${op} ${value}'`);
+                throw new Error("Potential SQL injection detected: '".concat(column, " ").concat(op, " ").concat(value, "'"));
             }
-            this.validateOperator(op);
+            _this.validateOperator(op);
             if (op === C6C.MATCH_AGAINST && Array.isArray(value)) {
-                const [search, mode] = value;
-                const paramName = this.useNamedParams ? `param${Object.keys(params).length}` : null;
-                if (this.useNamedParams) {
+                var search = value[0], mode = value[1];
+                var paramName = _this.useNamedParams ? "param".concat(Object.keys(params).length) : null;
+                if (_this.useNamedParams) {
                     params[paramName] = search;
                 }
                 else {
                     params.push(search);
                 }
-                let againstClause;
+                var againstClause = void 0;
                 switch ((mode || '').toUpperCase()) {
                     case 'BOOLEAN':
-                        againstClause = this.useNamedParams ? `AGAINST(:${paramName} IN BOOLEAN MODE)` : `AGAINST(? IN BOOLEAN MODE)`;
+                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, " IN BOOLEAN MODE)") : "AGAINST(? IN BOOLEAN MODE)";
                         break;
                     case 'WITH QUERY EXPANSION':
-                        againstClause = this.useNamedParams ? `AGAINST(:${paramName} WITH QUERY EXPANSION)` : `AGAINST(? WITH QUERY EXPANSION)`;
+                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, " WITH QUERY EXPANSION)") : "AGAINST(? WITH QUERY EXPANSION)";
                         break;
                     default: // NATURAL or undefined
-                        againstClause = this.useNamedParams ? `AGAINST(:${paramName})` : `AGAINST(?)`;
+                        againstClause = _this.useNamedParams ? "AGAINST(:".concat(paramName, ")") : "AGAINST(?)";
                         break;
                 }
                 if (!leftIsCol) {
-                    throw new Error(`MATCH_AGAINST requires a table reference as the left operand. Column '${column}' is not a valid table reference.`);
+                    throw new Error("MATCH_AGAINST requires a table reference as the left operand. Column '".concat(column, "' is not a valid table reference."));
                 }
-                const matchClause = `(MATCH(${column}) ${againstClause})`;
-                this.config.verbose && console.log(`[MATCH_AGAINST] ${matchClause}`);
+                var matchClause = "(MATCH(".concat(column, ") ").concat(againstClause, ")");
+                _this.config.verbose && console.log("[MATCH_AGAINST] ".concat(matchClause));
                 return matchClause;
             }
             if ((op === C6C.IN || op === C6C.NOT_IN) && Array.isArray(value)) {
-                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 '${column}' is not a valid table reference.`);
+                var placeholders = value.map(function (v) {
+                    return _this.isColumnRef(v) ? v : _this.addParam(params, column, v);
+                }).join(', ');
+                var normalized = op.replace('_', ' ');
+                if (!leftIsRef) {
+                    throw new Error("IN operator requires a table reference as the left operand. Column '".concat(column, "' is not a valid table reference."));
                 }
-                return `( ${column} ${normalized} (${placeholders}) )`;
+                return "( ".concat(column, " ").concat(normalized, " (").concat(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: ${JSON.stringify(value)}`);
+                    throw new Error("BETWEEN operator requires an array of two values");
                 }
-                const [start, end] = value;
-                if (!leftIsCol) {
-                    throw new Error(`BETWEEN operator requires a table reference as the left operand. Column '${column}' is not a valid table reference.`);
+                var start = value[0], end = value[1];
+                if (!leftIsRef) {
+                    throw new Error("BETWEEN operator requires a table reference as the left operand. Column '".concat(column, "' is not a valid table reference."));
                 }
-                return `(${column}) ${op.replace('_', ' ')} ${this.addParam(params, column, start)} AND ${this.addParam(params, column, end)}`;
+                return "(".concat(column, ") ").concat(op.replace('_', ' '), " ").concat(_this.addParam(params, column, start), " AND ").concat(_this.addParam(params, column, end));
             }
-            if (leftIsCol && rightIsCol) {
-                return `(${column}) ${op} ${value}`;
+            var rightIsRef = _this.isTableReference(value);
+            if (leftIsRef && rightIsRef) {
+                return "(".concat(column, ") ").concat(op, " ").concat(value);
             }
-            if (leftIsCol && !rightIsCol) {
-                return `(${column}) ${op} ${this.addParam(params, column, value)}`;
+            if (leftIsRef && !rightIsRef) {
+                return "(".concat(column, ") ").concat(op, " ").concat(_this.addParam(params, column, value));
             }
-            if (rightIsCol) {
-                return `(${this.addParam(params, column, column)}) ${op} ${value}`;
+            if (rightIsRef) {
+                return "(".concat(_this.addParam(params, column, column), ") ").concat(op, " ").concat(value);
             }
-            throw new Error(`Neither operand appears to be a table reference`);
+            throw new Error("Neither operand appears to be a table reference");
         };
-        const parts = [];
-        const buildFromObject = (obj, mode) => {
-            const subParts = [];
-            for (const [k, v] of Object.entries(obj)) {
+        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];
                 // numeric keys represent nested OR groups
                 if (!isNaN(Number(k))) {
-                    const sub = this.buildBooleanJoinedConditions(v, false, params);
+                    var sub = _this.buildBooleanJoinedConditions(v, false, params);
                     if (sub)
                         subParts.push(sub);
                     continue;
                 }
                 if (typeof v === 'object' && v !== null && Object.keys(v).length === 1) {
-                    const [op, val] = Object.entries(v)[0];
+                    var _c = Object.entries(v)[0], op = _c[0], val = _c[1];
                     subParts.push(addCondition(k, op, val));
                 }
                 else if (Array.isArray(v) && v.length >= 2 && typeof v[0] === 'string') {
-                    const [op, val] = v;
+                    var _d = v, op = _d[0], val = _d[1];
                     subParts.push(addCondition(k, op, val));
                 }
                 else if (typeof v === 'object' && v !== null) {
-                    const sub = this.buildBooleanJoinedConditions(v, mode, params);
+                    var sub = _this.buildBooleanJoinedConditions(v, mode, params);
                     if (sub)
                         subParts.push(sub);
                 }
@@ -1333,105 +1445,126 @@ class ConditionBuilder extends AggregateBuilder {
                     subParts.push(addCondition(k, '=', v));
                 }
             }
-            return subParts.join(` ${mode ? 'AND' : 'OR'} `);
+            return subParts.join(" ".concat(mode ? 'AND' : 'OR', " "));
         };
         if (Array.isArray(set)) {
-            for (const item of set) {
-                const sub = this.buildBooleanJoinedConditions(item, false, params);
+            for (var _i = 0, set_1 = set; _i < set_1.length; _i++) {
+                var item = set_1[_i];
+                var sub = this.buildBooleanJoinedConditions(item, false, params);
                 if (sub)
                     parts.push(sub);
             }
         }
         else if (typeof set === 'object' && set !== null) {
-            const sub = buildFromObject(set, andMode);
+            var sub = buildFromObject(set, andMode);
             if (sub)
                 parts.push(sub);
         }
-        const clause = parts.join(` ${booleanOperator} `);
-        return clause ? `(${clause})` : '';
-    }
-    buildWhereClause(whereArg, params) {
-        const clause = this.buildBooleanJoinedConditions(whereArg, true, params);
+        var clause = parts.join(" ".concat(booleanOperator, " "));
+        return clause ? "(".concat(clause, ")") : '';
+    };
+    ConditionBuilder.prototype.buildWhereClause = function (whereArg, params) {
+        var clause = this.buildBooleanJoinedConditions(whereArg, true, params);
         if (!clause)
             return '';
-        const trimmed = clause.replace(/^\((.*)\)$/, '$1');
-        this.config.verbose && console.log(`[WHERE] ${trimmed}`);
-        return ` WHERE ${trimmed}`;
-    }
-}
+        var trimmed = clause.replace(/^\((.*)\)$/, '$1');
+        this.config.verbose && console.log("[WHERE] ".concat(trimmed));
+        return " WHERE ".concat(trimmed);
+    };
+    return ConditionBuilder;
+}(AggregateBuilder));
 
-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(' ');
+var JoinBuilder = /** @class */ (function (_super) {
+    __extends(JoinBuilder, _super);
+    function JoinBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    JoinBuilder.prototype.buildJoinClauses = function (joinArgs, params) {
+        var sql = '';
+        for (var joinType in joinArgs) {
+            var joinKind = joinType.replace('_', ' ').toUpperCase();
+            for (var raw in joinArgs[joinType]) {
+                var _a = raw.split(' '), table = _a[0], alias = _a[1];
                 this.aliasMap[alias || table] = table;
-                const onClause = this.buildBooleanJoinedConditions(joinArgs[joinType][raw], true, params);
-                const joinSql = alias ? `\`${table}\` AS \`${alias}\`` : `\`${table}\``;
-                sql += ` ${joinKind} JOIN ${joinSql} ON ${onClause}`;
+                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);
             }
         }
-        this.config.verbose && console.log(`[JOIN] ${sql.trim()}`);
+        this.config.verbose && console.log("[JOIN] ".concat(sql.trim()));
         return sql;
-    }
-}
+    };
+    return JoinBuilder;
+}(ConditionBuilder));
 
-class DeleteQueryBuilder extends JoinBuilder {
-    build(table) {
-        const params = this.useNamedParams ? {} : [];
+var DeleteQueryBuilder = /** @class */ (function (_super) {
+    __extends(DeleteQueryBuilder, _super);
+    function DeleteQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DeleteQueryBuilder.prototype.build = function (table) {
+        this.aliasMap = {};
+        var params = this.useNamedParams ? {} : [];
         this.initAlias(table, this.request.JOIN);
-        let sql = `DELETE \`${table}\` FROM \`${table}\``;
+        var sql = "DELETE `".concat(table, "` FROM `").concat(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, params };
-    }
-}
+        return { sql: sql, params: params };
+    };
+    return DeleteQueryBuilder;
+}(JoinBuilder));
 
-class PostQueryBuilder extends ConditionBuilder {
-    trimTablePrefix(table, column) {
+var PostQueryBuilder = /** @class */ (function (_super) {
+    __extends(PostQueryBuilder, _super);
+    function PostQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PostQueryBuilder.prototype.trimTablePrefix = function (table, column) {
         if (!column.includes('.'))
             return column;
-        const [prefix, col] = column.split('.', 2);
+        var _a = column.split('.', 2), prefix = _a[0], col = _a[1];
         if (prefix !== table) {
-            throw new Error(`Invalid prefixed column: '${column}'. Expected prefix '${table}.'`);
+            throw new Error("Invalid prefixed column: '".concat(column, "'. Expected prefix '").concat(table, ".'"));
         }
         return col;
-    }
-    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);
+    };
+    PostQueryBuilder.prototype.build = function (table) {
+        var _this = this;
+        this.aliasMap = {};
+        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);
             placeholders.push(placeholder);
         }
-        let sql = `${verb} INTO \`${table}\` (
-            ${keys.map(k => `\`${this.trimTablePrefix(table, k)}\``).join(', ')}
-         ) VALUES (
-            ${placeholders.join(', ')}
-        )`;
+        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        )");
         if (C6C.UPDATE in this.request) {
-            const updateData = this.request[C6C.UPDATE];
+            var updateData = this.request[C6C.UPDATE];
             if (!Array.isArray(updateData)) {
-                throw new Error(`Update data must be an array of keys to update, got: ${JSON.stringify(updateData)}`);
+                throw new Error("Update data must be an array of keys to update, got: ".concat(JSON.stringify(updateData)));
             }
-            const updateClause = updateData.map(k => `\`${k}\` = VALUES(\`${k}\`)`).join(', ');
-            sql += ` ON DUPLICATE KEY UPDATE ${updateClause}`;
+            var updateClause = updateData.map(function (k) { return "`".concat(k, "` = VALUES(`").concat(k, "`)"); }).join(', ');
+            sql += " ON DUPLICATE KEY UPDATE ".concat(updateClause);
         }
-        return { sql, params };
-    }
-}
+        return { sql: sql, params: params };
+    };
+    return PostQueryBuilder;
+}(ConditionBuilder));
 
-class PaginationBuilder extends JoinBuilder {
+var PaginationBuilder = /** @class */ (function (_super) {
+    __extends(PaginationBuilder, _super);
+    function PaginationBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
     /**
      * MySQL ORDER/LIMIT/OFFSET generator.
      *
@@ -1445,49 +1578,61 @@ class PaginationBuilder extends JoinBuilder {
      * }
      * ```
      */
-    buildPaginationClause(pagination) {
-        let sql = "";
+    PaginationBuilder.prototype.buildPaginationClause = function (pagination) {
+        var _this = this;
+        var _a;
+        var sql = "";
         /* -------- ORDER BY -------- */
-        if (pagination?.[C6Constants.ORDER]) {
-            const orderParts = [];
-            for (const [key, val] of Object.entries(pagination[C6Constants.ORDER])) {
+        if (pagination === null || pagination === void 0 ? void 0 : pagination[C6Constants.ORDER]) {
+            var orderParts = [];
+            for (var _i = 0, _b = Object.entries(pagination[C6Constants.ORDER]); _i < _b.length; _i++) {
+                var _c = _b[_i], key = _c[0], val = _c[1];
                 // FUNCTION CALL: val is an array of args
                 if (Array.isArray(val)) {
-                    const args = val
-                        .map((arg) => Array.isArray(arg) ? this.buildAggregateField(arg) : String(arg))
+                    var args = val
+                        .map(function (arg) { return Array.isArray(arg) ? _this.buildAggregateField(arg) : String(arg); })
                         .join(", ");
-                    orderParts.push(`${key}(${args})`);
+                    orderParts.push("".concat(key, "(").concat(args, ")"));
                 }
                 // SIMPLE COLUMN + DIR (ASC/DESC)
                 else {
-                    orderParts.push(`${key} ${String(val).toUpperCase()}`);
+                    orderParts.push("".concat(key, " ").concat(String(val).toUpperCase()));
                 }
             }
             if (orderParts.length)
-                sql += ` ORDER BY ${orderParts.join(", ")}`;
+                sql += " ORDER BY ".concat(orderParts.join(", "));
         }
         /* -------- LIMIT / OFFSET -------- */
-        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}`;
+        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);
         }
-        this.config.verbose && console.log(`[PAGINATION] ${sql.trim()}`);
+        this.config.verbose && console.log("[PAGINATION] ".concat(sql.trim()));
         return sql;
-    }
-}
+    };
+    return PaginationBuilder;
+}(JoinBuilder));
 
-class SelectQueryBuilder extends PaginationBuilder {
-    build(table, isSubSelect = false) {
-        const args = this.request;
+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; }
+        this.aliasMap = {};
+        var args = this.request;
         this.initAlias(table, args.JOIN);
-        const params = this.useNamedParams ? {} : [];
-        const selectList = args.SELECT ?? ['*'];
-        const selectFields = selectList
-            .map((f) => this.buildAggregateField(f))
+        var params = this.useNamedParams ? {} : [];
+        var selectList = (_a = args.SELECT) !== null && _a !== void 0 ? _a : ['*'];
+        var selectFields = selectList
+            .map(function (f) { return _this.buildAggregateField(f); })
             .join(', ');
-        let sql = `SELECT ${selectFields} FROM \`${table}\``;
+        var sql = "SELECT ".concat(selectFields, " FROM `").concat(table, "`");
         if (args.JOIN) {
             sql += this.buildJoinClauses(args.JOIN, params);
         }
@@ -1495,165 +1640,229 @@ class SelectQueryBuilder extends PaginationBuilder {
             sql += this.buildWhereClause(args.WHERE, params);
         }
         if (args.GROUP_BY) {
-            const groupBy = Array.isArray(args.GROUP_BY)
+            var groupBy = Array.isArray(args.GROUP_BY)
                 ? args.GROUP_BY.join(', ')
                 : args.GROUP_BY;
-            sql += ` GROUP BY ${groupBy}`;
+            sql += " GROUP BY ".concat(groupBy);
         }
         if (args.HAVING) {
-            sql += ` HAVING ${this.buildBooleanJoinedConditions(args.HAVING, true, params)}`;
+            sql += " HAVING ".concat(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] ${sql.trim()}`);
-        return { sql, params };
-    }
-}
+        console.log("[SELECT] ".concat(sql.trim()));
+        return { sql: sql, params: params };
+    };
+    return SelectQueryBuilder;
+}(PaginationBuilder));
 
-class UpdateQueryBuilder extends PaginationBuilder {
-    build(table) {
-        const args = this.request;
-        const params = this.useNamedParams ? {} : [];
+var UpdateQueryBuilder = /** @class */ (function (_super) {
+    __extends(UpdateQueryBuilder, _super);
+    function UpdateQueryBuilder() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UpdateQueryBuilder.prototype.build = function (table) {
+        var _this = this;
+        this.aliasMap = {};
+        var args = this.request;
+        var params = this.useNamedParams ? {} : [];
         this.initAlias(table, args.JOIN);
-        let sql = `UPDATE \`${table}\``;
+        var sql = "UPDATE `".concat(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.");
         }
-        const setClauses = Object.entries(this.request[C6C.UPDATE]).map(([col, val]) => this.addParam(params, col, val));
-        sql += ` SET ${setClauses.join(', ')}`;
+        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(', '));
         if (args.WHERE) {
             sql += this.buildWhereClause(args.WHERE, params);
         }
         if (args.PAGINATION) {
             sql += this.buildPaginationClause(args.PAGINATION);
         }
-        return { sql, params };
-    }
-}
+        return { sql: sql, params: params };
+    };
+    return UpdateQueryBuilder;
+}(PaginationBuilder));
 
-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}`);
-        }
-    }
-    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();
-        }
+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;
     }
-    serialize = (row) => Object.fromEntries(Object.entries(row).map(([k, v]) => [k, Buffer$1.isBuffer(v) ? v.toString('hex').toUpperCase() : v]));
-    formatSQLWithParams(sql, params) {
+    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 body:", this.request.body);
+                        this.config.verbose && console.log("[SQL EXECUTOR] \uD83E\uDDE9 Request query:", this.request.query);
+                        _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;
         if (Array.isArray(params)) {
-            let index = 0;
-            return sql.replace(/\?/g, () => {
-                if (index >= params.length)
+            var index_1 = 0;
+            return sql.replace(/\?/g, function () {
+                if (index_1 >= params.length)
                     return '?';
-                const val = params[index++];
-                return this.formatValue(val);
+                var val = params[index_1++];
+                return _this.formatValue(val);
             });
         }
         else {
-            return sql.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
-                const val = params[key];
-                return this.formatValue(val);
+            return sql.replace(/:([a-zA-Z0-9_]+)/g, function (_, key) {
+                var val = params[key];
+                return _this.formatValue(val);
             });
         }
-    }
-    formatValue(val) {
+    };
+    SqlExecutor.prototype.formatValue = function (val) {
         if (val === null || val === undefined)
             return 'NULL';
         if (Buffer$1.isBuffer(val))
-            return `UNHEX('${val.toString('hex')}')`;
+            return "UNHEX('".concat(val.toString('hex'), "')");
         if (typeof val === 'string')
-            return `'${val.replace(/'/g, "''")}'`;
+            return "'".concat(val.replace(/'/g, "''"), "'");
         if (typeof val === 'number')
             return val.toString();
         if (val instanceof Date)
-            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 "'".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 SqlExecutor;
+}(Executor));
 
 var SqlExecutor$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1662,80 +1871,101 @@ 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({ 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;
+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*/];
                     }
-                    break;
-                case 'PUT':
-                case 'DELETE':
-                    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*/];
                     }
-                    else {
-                        res.status(400).json({ error: `Invalid request: ${method} requires a primary key.` });
+                    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*/];
                     }
-                    break;
-                case 'POST':
-                    break;
-                default:
-                    res.status(405).json({ error: `Method ${method} not allowed` });
-                    return;
+                    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*/];
             }
-            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
-const A = (tableName, alias) => `${tableName} ${alias}`;
+var A = function (tableName, alias) {
+    return "".concat(tableName, " ").concat(alias);
+};
 // Qualify a column constant (e.g. 'property_units.parcel_id') to an alias
-const F = (qualifiedCol, alias) => `${alias}.${qualifiedCol.split('.').pop()}`;
+var F = function (qualifiedCol, alias) {
+    return "".concat(alias, ".").concat(qualifiedCol.split('.').pop());
+};
 // Equal join condition using full-qualified column constants
-const fieldEq = (leftCol, rightCol, leftAlias, rightAlias) => ({
-    [F(leftCol, leftAlias)]: F(rightCol, rightAlias)
-});
+var fieldEq = function (leftCol, rightCol, leftAlias, rightAlias) {
+    var _a;
+    return (_a = {},
+        _a[F(leftCol, leftAlias)] = F(rightCol, rightAlias),
+        _a);
+};
 // ST_Distance_Sphere for aliased fields
-const distSphere = (fromCol, toCol, fromAlias, toAlias) => [C6C.ST_DISTANCE_SPHERE, F(fromCol, fromAlias), F(toCol, toAlias)];
+var distSphere = function (fromCol, toCol, fromAlias, toAlias) {
+    return [C6C.ST_DISTANCE_SPHERE, F(fromCol, fromAlias), F(toCol, toAlias)];
+};
 
 function determineRuntimeJsType(mysqlType) {
-    const base = mysqlType.toLowerCase().split('(')[0];
+    var base = mysqlType.toLowerCase().split('(')[0];
     if ([
         'binary', 'varbinary', 'blob', 'tinyblob', 'mediumblob', 'longblob'
     ].includes(base))
@@ -1756,15 +1986,23 @@ function determineRuntimeJsType(mysqlType) {
     return 'string';
 }
 function getPrimaryKeyTypes(table) {
-    const result = {};
-    for (const key of table.PRIMARY_SHORT) {
-        const fullKey = Object.entries(table.COLUMNS).find(([_, short]) => short === key)?.[0];
+    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];
         if (typeof fullKey === 'string') {
-            const validation = table.TYPE_VALIDATION[fullKey];
+            var validation = table.TYPE_VALIDATION[fullKey];
             if (!validation)
-                continue;
+                return "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;
 }
@@ -1773,30 +2011,42 @@ function getPrimaryKeyTypes(table) {
  * Conditionally group a log if verbose.
  */
 function group(title, data) {
-    console.groupCollapsed(`%c${title}`, "color: #007acc");
+    console.groupCollapsed("%c".concat(title), "color: #007acc");
     if (data !== undefined)
         console.log(data);
     console.groupEnd();
 }
-function info(message, ...optional) {
-    console.info(`%cINFO: ${message}`, "color: #0a0", ...optional);
+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 warn(message, ...optional) {
-    console.warn(`%cWARN: ${message}`, "color: #e90", ...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 error(message, ...optional) {
-    console.error(`%cERROR: ${message}`, "color: #c00", ...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 checkAllRequestsComplete() {
-    const stillRunning = apiRequestCache.filter((cache) => undefined === cache.response);
+    var stillRunning = apiRequestCache.filter(function (cache) { return undefined === cache.response; });
     if (stillRunning.length !== 0) {
         if (document === null || document === undefined) {
             throw new Error('document is undefined while waiting for API requests to complete (' + JSON.stringify(apiRequestCache) + ')');
         }
         // when requests return emtpy sets in full renders, it may not be possible to track their progress.
         console.warn('stillRunning...', stillRunning);
-        return stillRunning.map((cache) => cache.requestArgumentsSerialized);
+        return stillRunning.map(function (cache) { return cache.requestArgumentsSerialized; });
     }
     return true;
 }
@@ -1809,7 +2059,7 @@ function onError(message) {
 }
 
 function isVerbose () {
-    const envVerbose = getEnvVar('VERBOSE') || getEnvVar('REACT_APP_VERBOSE') || getEnvVar('VITE_VERBOSE') || '';
+    var envVerbose = getEnvVar('VERBOSE') || getEnvVar('REACT_APP_VERBOSE') || getEnvVar('VITE_VERBOSE') || '';
     return ['true', '1', 'yes', 'on'].includes(envVerbose.toLowerCase());
 }