@carbonorm/carbonnode 3.0.3 → 3.0.5

package/dist/index.esm.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import Qs from 'qs';
-import { __assign, __awaiter, __spreadArray, __generator, __extends } from 'tslib';
+import { __assign, __awaiter, __generator, __extends, __spreadArray } from 'tslib';
 import { toast } from 'react-toastify';
 
 var C6Constants = {
@@ -236,65 +236,70 @@ function convertForRequestBody (restfulObject, tableName, C6, regexErrorHandler)
     if (regexErrorHandler === void 0) { regexErrorHandler = alert; }
     var payload = {};
     var tableNames = Array.isArray(tableName) ? tableName : [tableName];
-    var tableDefinitions = [];
-    tableNames.forEach(function (tableName) {
-        var tableDefinition = Object.values(C6.TABLES).find(function (tableDefinition) { return tableDefinition.TABLE_NAME === tableName; });
-        if (undefined === tableDefinition) {
-            console.error("Table name (".concat(tableName, ") is not found in the C6.TABLES object."), C6.TABLES);
-            throw new Error("Table name (".concat(tableName, ") is not found in the C6.TABLES object."));
+    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 (".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."));
         }
-        tableDefinitions.push(tableDefinition);
+        return tableDefinition;
     });
-    tableDefinitions.forEach(function (tableDefinition) {
-        Object.keys(restfulObject).forEach(function (value) {
-            var _a;
+    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();
-            switch (value) {
-                case C6Constants.GET:
-                case C6Constants.POST:
-                case C6Constants.UPDATE:
-                case C6Constants.REPLACE:
-                case C6Constants.DELETE:
-                case C6Constants.WHERE:
-                case C6Constants.JOIN:
-                case C6Constants.PAGINATION:
-                    if (Array.isArray(restfulObject[value])) {
-                        payload[value] = restfulObject[value].sort();
-                    }
-                    else if (typeof restfulObject[value] === 'object' && restfulObject[value] !== null) {
-                        payload[value] = Object.keys(restfulObject[value])
-                            .sort()
-                            .reduce(function (acc, key) {
-                            var _a;
-                            return (__assign(__assign({}, acc), (_a = {}, _a[key] = restfulObject[value][key], _a)));
-                        }, {});
-                    }
-                    return;
+            if ([
+                C6Constants.GET,
+                C6Constants.POST,
+                C6Constants.UPDATE,
+                C6Constants.REPLACE,
+                C6Constants.DELETE,
+                C6Constants.WHERE,
+                C6Constants.JOIN,
+                C6Constants.PAGINATION
+            ].includes(value)) {
+                var val_1 = restfulObject[value];
+                if (Array.isArray(val_1)) {
+                    payload[value] = val_1.sort();
+                }
+                else if (typeof val_1 === 'object' && val_1 !== null) {
+                    payload[value] = Object.keys(val_1)
+                        .sort()
+                        .reduce(function (acc, key) {
+                        var _a;
+                        return (__assign(__assign({}, acc), (_a = {}, _a[key] = val_1[key], _a)));
+                    }, {});
+                }
+                return "continue";
             }
             if (shortReference in tableDefinition) {
-                var longName_1 = tableDefinition[shortReference];
-                payload[longName_1] = restfulObject[value];
-                var regexValidations_1 = tableDefinition.REGEX_VALIDATION[longName_1];
-                if (regexValidations_1 instanceof RegExp) {
-                    if (false === regexValidations_1.test(restfulObject[value])) {
-                        regexErrorHandler('Failed to match regex (' + regexValidations_1 + ') for column (' + longName_1 + ')');
-                        throw Error('Failed to match regex (' + regexValidations_1 + ') for column (' + longName_1 + ')');
+                var longName = tableDefinition[shortReference];
+                var columnValue = restfulObject[value];
+                payload[longName] = columnValue;
+                var regexValidations = tableDefinition.REGEX_VALIDATION[longName];
+                if (regexValidations instanceof RegExp) {
+                    if (!regexValidations.test(columnValue)) {
+                        regexErrorHandler("Failed to match regex (".concat(regexValidations, ") for column (").concat(longName, ")"));
+                        throw new Error("Failed to match regex (".concat(regexValidations, ") for column (").concat(longName, ")"));
                     }
                 }
-                else if (typeof regexValidations_1 === 'object' && regexValidations_1 !== null) {
-                    (_a = Object.keys(regexValidations_1)) === null || _a === void 0 ? void 0 : _a.forEach(function (errorMessage) {
-                        var regex = regexValidations_1[errorMessage];
-                        if (false === regex.test(restfulObject[value])) {
-                            var devErrorMessage = 'Failed to match regex (' + regex + ') for column (' + longName_1 + ')';
-                            regexErrorHandler(errorMessage !== null && errorMessage !== void 0 ? errorMessage : devErrorMessage);
-                            throw Error(devErrorMessage);
+                else if (typeof regexValidations === 'object' && regexValidations !== null) {
+                    for (var errorMessage in regexValidations) {
+                        var regex = regexValidations[errorMessage];
+                        if (!regex.test(columnValue)) {
+                            var devErrorMessage = "Failed to match regex (".concat(regex, ") for column (").concat(longName, ")");
+                            regexErrorHandler(errorMessage || devErrorMessage);
+                            throw new Error(devErrorMessage);
                         }
-                    });
+                    }
                 }
             }
-        });
-        return true;
-    });
+        };
+        for (var _a = 0, _b = Object.keys(restfulObject); _a < _b.length; _a++) {
+            var value = _b[_a];
+            _loop_1(value);
+        }
+    }
     return Object.keys(payload)
         .sort()
         .reduce(function (acc, key) {
@@ -311,32 +316,25 @@ var isNode = typeof process !== 'undefined' && !!((_a = process.versions) === nu
  */
 function restRequest(config) {
     var _this = this;
-    return function () {
-        var args_1 = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args_1[_i] = arguments[_i];
-        }
-        return __awaiter(_this, __spreadArray([], args_1, true), void 0, function (request) {
-            var SqlExecutor, executor, HttpExecutor, http;
-            if (request === void 0) { request = {}; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(isNode && config.mysqlPool)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, Promise.resolve().then(function () { return SqlExecutor$1; })];
-                    case 1:
-                        SqlExecutor = (_a.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 = (_a.sent()).HttpExecutor;
-                        http = new HttpExecutor(config, request);
-                        return [2 /*return*/, http.execute()];
-                }
-            });
+    return function (request) { return __awaiter(_this, void 0, void 0, function () {
+        var SqlExecutor, executor, HttpExecutor, http;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(isNode && config.mysqlPool)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, Promise.resolve().then(function () { return SqlExecutor$1; })];
+                case 1:
+                    SqlExecutor = (_a.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 = (_a.sent()).HttpExecutor;
+                    http = new HttpExecutor(config, request);
+                    return [2 /*return*/, http.execute()];
+            }
         });
-    };
+    }); };
 }
 
 function restOrm(config) {
@@ -541,7 +539,6 @@ var isVerbose = ['true', '1', 'yes', 'on'].includes(envVerbose.toLowerCase());
 
 var Executor = /** @class */ (function () {
     function Executor(config, request) {
-        if (request === void 0) { request = {}; }
         this.config = config;
         this.request = request;
     }
@@ -610,23 +607,11 @@ var eFetchDependencies;
     eFetchDependencies[eFetchDependencies["RECURSIVE"] = 8] = "RECURSIVE";
 })(eFetchDependencies || (eFetchDependencies = {}));
 
-/**
- * the first argument ....
- *
- * Our api returns a zero argument function iff the method is get and the previous request reached the predefined limit.
- * This function can be aliased as GetNextPageOfResults(). If the end is reached undefined will be returned.
- *
- *
- * For POST, PUT, and DELETE requests one can expect the primary key of the new or modified index, or a boolean success
- * indication if no primary key exists.
- **/
+// Refined TypeScript types for CarbonORM
 var POST = 'POST';
 var PUT = 'PUT';
 var GET = 'GET';
 var DELETE = 'DELETE';
-function isPromise(x) {
-    return Object(x).constructor === Promise;
-}
 
 var toastOptions = {
     position: "bottom-left",
@@ -788,11 +773,12 @@ var HttpExecutor = /** @class */ (function (_super) {
     };
     HttpExecutor.prototype.execute = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, C6, restModel, requestMethod, clearCache, tableName, fullTableList, operatingTableFullName, tables;
+            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, _a.axios, _a.restURL, _a.withCredentials, restModel = _a.restModel, _a.reactBootstrap, requestMethod = _a.requestMethod, _a.skipPrimaryCheck, clearCache = _a.clearCache;
+                        _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;
                         return [4 /*yield*/, this.runLifecycleHooks("beforeProcessing", {
                                 config: this.config,
                                 request: this.request,
@@ -802,7 +788,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                         tableName = restModel.TABLE_NAME;
                         fullTableList = Array.isArray(tableName) ? tableName : [tableName];
                         operatingTableFullName = fullTableList[0];
-                        removePrefixIfExists(operatingTableFullName, C6.PREFIX);
+                        operatingTable = removePrefixIfExists(operatingTableFullName, C6.PREFIX);
                         tables = fullTableList.join(',');
                         switch (requestMethod) {
                             case GET:
@@ -819,16 +805,483 @@ var HttpExecutor = /** @class */ (function (_super) {
                         console.groupCollapsed('%c API: (' + requestMethod + ') Request for (' + tableName + ')', 'color: #0c0');
                         console.log('request', this.request);
                         console.groupEnd();
-                        {
-                            if (this.request.debug && isDevelopment) {
-                                toast.warning("DEV: queryCallback returned undefined, signaling in Custom Cache. (returning null)", toastOptionsDevs);
-                            }
-                            console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + tableName + ') undefined, returning null (will not fire ajax)!', 'color: #c00');
+                        // 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];
                         }
+                        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;
+                        }
+                        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) {
+                                _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;
+                                // determine if we need to paginate.
+                                if (requestMethod === C6.GET) {
+                                    if (undefined === (query === null || query === void 0 ? void 0 : query[C6.PAGINATION])) {
+                                        if (undefined === query || null === query) {
+                                            query = {};
+                                        }
+                                        query[C6.PAGINATION] = {};
+                                    }
+                                    query[C6.PAGINATION][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) {
+                                            do {
+                                                cacheCheck = checkCache(cacheResult, requestMethod, tableName, this.request);
+                                                if (false !== cacheCheck) {
+                                                    return [2 /*return*/, cacheCheck];
+                                                }
+                                                // 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; });
+                                            } while (undefined !== cacheResult);
+                                            if (debug && isDevelopment) {
+                                                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];
+                                        }
+                                        cachingConfirmed = true;
+                                    }
+                                    else {
+                                        if (debug && isDevelopment) {
+                                            toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
+                                        }
+                                    }
+                                    if (debug && isDevelopment) {
+                                        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) {
+                                        cacheCheck = checkCache(cacheResult, requestMethod, tableName, this.request);
+                                        if (false !== cacheCheck) {
+                                            return [2 /*return*/, cacheCheck];
+                                        }
+                                    }
+                                    cachingConfirmed = true;
+                                    // push to cache so we do not repeat the request
+                                }
+                                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 && isDevelopment) {
+                                                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.');
+                                        }
+                                    }
+                                }
+                                // A part of me exists that wants to remove this, but it's a good feature
+                                // this allows developers the ability to cache requests based on primary key
+                                // for tables like `photos` this can be a huge performance boost
+                                if (undefined !== query
+                                    && null !== query
+                                    && undefined !== primaryKey
+                                    && primaryKey in query) {
+                                    restRequestUri += query[primaryKey] + '/';
+                                    removedPkValue_1 = query[primaryKey];
+                                    addBackPK = function () {
+                                        query !== null && query !== void 0 ? query : (query = {});
+                                        query[primaryKey] = removedPkValue_1;
+                                    };
+                                    delete query[primaryKey];
+                                    console.log('query', query, 'primaryKey', primaryKey, 'removedPkValue', removedPkValue_1);
+                                }
+                                else {
+                                    console.log('query', query);
+                                }
+                                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
+                                        });
+                                    }
+                                    // 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, _k;
+                                            return __generator(this, function (_l) {
+                                                switch (_l.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; });
+                                                            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 && isDevelopment) {
+                                                                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:
+                                                                    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 || true === isVerbose) {
+                                                            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:' + (1 !== ((_h = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _h === void 0 ? void 0 : _h[C6.LIMIT]) ? '' : ' (Will not return with explicit limit 1 set)'), 'color: #0c0', true === returnGetNextPageFunction);
+                                                            console.trace();
+                                                            console.groupEnd();
+                                                        }
+                                                        if (false === returnGetNextPageFunction
+                                                            && true === debug
+                                                            && isDevelopment) {
+                                                            toast.success("DEVS: Response returned length (" + ((_j = responseData_1.rest) === null || _j === void 0 ? void 0 : _j.length) + ") less than limit (" + ((_k = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _k === void 0 ? void 0 : _k[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 = {};
+                                                        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 _m;
+                                                            return __generator(this, function (_o) {
+                                                                switch (_o.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 = _o.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((_m = {},
+                                                                            _m[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;
+                                                                                }, {})
+                                                                            },
+                                                                            _m.fetchDependencies = nextFetchDependencies,
+                                                                            _m)));
+                                                                        return [2 /*return*/];
+                                                                }
+                                                            });
+                                                        };
+                                                        _a = fetchReferences_1;
+                                                        _b = [];
+                                                        for (_c in _a)
+                                                            _b.push(_c);
+                                                        _i = 0;
+                                                        _l.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:
+                                                        _l.sent();
+                                                        _l.label = 3;
+                                                    case 3:
+                                                        _i++;
+                                                        return [3 /*break*/, 1];
+                                                    case 4:
+                                                        console.groupEnd();
+                                                        return [4 /*yield*/, Promise.all(apiRequestPromises)];
+                                                    case 5:
+                                                        _l.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*/];
+                                                                }
+                                                            });
+                                                        }); });
+                                                        _l.label = 6;
+                                                    case 6:
+                                                        if (debug && isDevelopment) {
+                                                            toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
+                                                        }
+                                                        return [2 /*return*/, response];
+                                                }
+                                            });
+                                        }); })];
+                                }
+                                catch (throwableError) {
+                                    if (isTest) {
+                                        throw new Error(JSON.stringify(throwableError));
+                                    }
+                                    console.groupCollapsed('%c API: An error occurred in the try catch block. returning null!', 'color: #ff0000');
+                                    console.log('%c ' + requestMethod + ' ' + tableName, 'color: #A020F0');
+                                    console.warn(throwableError);
+                                    console.trace();
+                                    console.groupEnd();
+                                    TestRestfulResponse(throwableError, success, error);
+                                    return [2 /*return*/, null];
+                                }
+                                return [2 /*return*/];
+                            });
+                        }); };
+                        return [4 /*yield*/, apiRequest()];
                     case 2: return [2 /*return*/, _b.sent()];
                 }
             });
@@ -1097,5 +1550,5 @@ function onError(message) {
     toast.error(message, isDevelopment ? toastOptionsDevs : toastOptions);
 }
 
-export { C6Constants, DELETE, Executor, GET, HttpExecutor, POST, PUT, SqlExecutor, TestRestfulResponse, apiRequestCache, axiosInstance, buildAggregateField, buildBooleanJoinedConditions, buildSelectQuery, checkAllRequestsComplete, checkCache, clearCache, convertForRequestBody, determineRuntimeJsType, eFetchDependencies, error, getEnvVar, getPrimaryKeyTypes, group, info, isDevelopment as isLocal, isNode, isPromise, isTest, isVerbose, onError, onSuccess, removeInvalidKeys, removePrefixIfExists, restOrm, restRequest, sortAndSerializeQueryObject, timeout, toastOptions, toastOptionsDevs, userCustomClearCache, warn };
+export { C6Constants, DELETE, Executor, GET, HttpExecutor, POST, PUT, SqlExecutor, TestRestfulResponse, apiRequestCache, axiosInstance, buildAggregateField, buildBooleanJoinedConditions, buildSelectQuery, checkAllRequestsComplete, checkCache, clearCache, convertForRequestBody, determineRuntimeJsType, eFetchDependencies, error, getEnvVar, getPrimaryKeyTypes, group, info, isDevelopment as isLocal, isNode, isTest, isVerbose, onError, onSuccess, removeInvalidKeys, removePrefixIfExists, restOrm, restRequest, sortAndSerializeQueryObject, timeout, toastOptions, toastOptionsDevs, userCustomClearCache, warn };
 //# sourceMappingURL=index.esm.js.map