@carbonorm/carbonnode 1.0.0

package/dist/carbonnode.cjs.js

@@ -0,0 +1,604 @@
+'use strict';
+
+var reactToastify = require('react-toastify');
+
+const C6 = {
+    // try to 1=1 match the Rest abstract class
+    ADDDATE: 'ADDDATE',
+    ADDTIME: 'ADDTIME',
+    AS: 'AS',
+    ASC: 'ASC',
+    BETWEEN: 'BETWEEN',
+    CONCAT: 'CONCAT',
+    CONVERT_TZ: 'CONVERT_TZ',
+    COUNT: 'COUNT',
+    COUNT_ALL: 'COUNT_ALL',
+    CURRENT_DATE: 'CURRENT_DATE',
+    CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP',
+    DAY: 'DAY',
+    DAY_HOUR: 'DAY_HOUR',
+    DAY_MICROSECOND: 'DAY_MICROSECOND',
+    DAY_MINUTE: 'DAY_MINUTE',
+    DAY_SECOND: 'DAY_SECOND',
+    DAYNAME: 'DAYNAME',
+    DAYOFMONTH: 'DAYOFMONTH',
+    DAYOFWEEK: 'DAYOFWEEK',
+    DAYOFYEAR: 'DAYOFYEAR',
+    DATE: 'DATE',
+    DATE_ADD: 'DATE_ADD',
+    DATEDIFF: 'DATEDIFF',
+    DATE_SUB: 'DATE_SUB',
+    DATE_FORMAT: 'DATE_FORMAT',
+    DESC: 'DESC',
+    DISTINCT: 'DISTINCT',
+    EXTRACT: 'EXTRACT',
+    EQUAL: '=',
+    EQUAL_NULL_SAFE: '<=>',
+    FALSE: 'FALSE',
+    FULL_OUTER: 'FULL_OUTER',
+    FROM_DAYS: 'FROM_DAYS',
+    FROM_UNIXTIME: 'FROM_UNIXTIME',
+    GET_FORMAT: 'GET_FORMAT',
+    GREATER_THAN: '>',
+    GROUP_BY: 'GROUP_BY',
+    GROUP_CONCAT: 'GROUP_CONCAT',
+    GREATER_THAN_OR_EQUAL_TO: '>=',
+    HAVING: 'HAVING',
+    HEX: 'HEX',
+    HOUR: 'HOUR',
+    HOUR_MICROSECOND: 'HOUR_MICROSECOND',
+    HOUR_SECOND: 'HOUR_SECOND',
+    HOUR_MINUTE: 'HOUR_MINUTE',
+    IN: 'IN',
+    IS: 'IS',
+    IS_NOT: 'IS_NOT',
+    INNER: 'INNER',
+    INTERVAL: 'INTERVAL',
+    JOIN: 'JOIN',
+    LEFT: 'LEFT',
+    LEFT_OUTER: 'LEFT_OUTER',
+    LESS_THAN: '<',
+    LESS_THAN_OR_EQUAL_TO: '<=',
+    LIKE: 'LIKE',
+    LIMIT: 'LIMIT',
+    LOCALTIME: 'LOCALTIME',
+    LOCALTIMESTAMP: 'LOCALTIMESTAMP',
+    MAKEDATE: 'MAKEDATE',
+    MAKETIME: 'MAKETIME',
+    MONTHNAME: 'MONTHNAME',
+    MICROSECOND: 'MICROSECOND',
+    MINUTE: 'MINUTE',
+    MINUTE_MICROSECOND: 'MINUTE_MICROSECOND',
+    MINUTE_SECOND: 'MINUTE_SECOND',
+    MIN: 'MIN',
+    MAX: 'MAX',
+    MONTH: 'MONTH',
+    NOT_LIKE: 'NOT_LIKE',
+    NOT_EQUAL: '<>',
+    NOT_IN: 'NOT_IN',
+    NOW: 'NOW',
+    NULL: 'NULL',
+    ORDER: 'ORDER',
+    PAGE: 'PAGE',
+    PAGINATION: 'PAGINATION',
+    RIGHT_OUTER: 'RIGHT_OUTER',
+    SECOND: 'SECOND',
+    SECOND_MICROSECOND: 'SECOND_MICROSECOND',
+    SELECT: 'SELECT',
+    STR_TO_DATE: 'STR_TO_DATE',
+    SUBDATE: 'SUBDATE',
+    SUBTIME: 'SUBTIME',
+    SUM: 'SUM',
+    SYSDATE: 'SYSDATE',
+    TIME: 'TIME',
+    TIME_FORMAT: 'TIME_FORMAT',
+    TIME_TO_SEC: 'TIME_TO_SEC',
+    TIMEDIFF: 'TIMEDIFF',
+    TIMESTAMP: 'TIMESTAMP',
+    TIMESTAMPADD: 'TIMESTAMPADD',
+    TIMESTAMPDIFF: 'TIMESTAMPDIFF',
+    TO_DAYS: 'TO_DAYS',
+    TO_SECONDS: 'TO_SECONDS',
+    TRANSACTION_TIMESTAMP: 'TRANSACTION_TIMESTAMP',
+    TRUE: 'TRUE',
+    UNIX_TIMESTAMP: 'UNIX_TIMESTAMP',
+    UNKNOWN: 'UNKNOWN',
+    UPDATE: 'UPDATE',
+    UNHEX: 'UNHEX',
+    UTC_DATE: 'UNHEX',
+    UTC_TIME: 'UNHEX',
+    UTC_TIMESTAMP: 'UNHEX',
+    WHERE: 'WHERE',
+    WEEKDAY: 'WEEKDAY',
+    WEEKOFYEAR: 'WEEKOFYEAR',
+    YEARWEEK: 'YEARWEEK',
+    // carbon identifiers
+    DEPENDANT_ON_ENTITY: 'DEPENDANT_ON_ENTITY',
+    // PHP validation
+    OPTIONS: 'OPTIONS',
+    GET: 'GET',
+    POST: 'POST',
+    PUT: 'PUT',
+    REPLACE: 'REPLACE INTO',
+    DELETE: 'DELETE',
+    REST_REQUEST_PREPROCESS_CALLBACKS: 'PREPROCESS',
+    PREPROCESS: 'PREPROCESS',
+    REST_REQUEST_FINNISH_CALLBACKS: 'FINISH',
+    FINISH: 'FINISH',
+    VALIDATE_C6_ENTITY_ID_REGEX: '#^([a-fA-F0-9]{20,35})$#',
+};
+
+function convertForRequestBody (restfulObject, tableName, regexErrorHandler = alert) {
+    let payload = {};
+    const tableNames = Array.isArray(tableName) ? tableName : [tableName];
+    tableNames.forEach((table) => {
+        Object.keys(restfulObject).map(value => {
+            var _a;
+            let shortReference = value.toUpperCase();
+            switch (value) {
+                case C6.GET:
+                case C6.POST:
+                case C6.UPDATE:
+                case C6.REPLACE:
+                case C6.DELETE:
+                case C6.WHERE:
+                case C6.JOIN:
+                case C6.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((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: restfulObject[value][key] })), {});
+                    }
+                    return;
+            }
+            if (shortReference in C6[table]) {
+                const longName = C6[table][shortReference];
+                payload[longName] = restfulObject[value];
+                const regexValidations = C6[table].REGEX_VALIDATION[longName];
+                if (regexValidations instanceof RegExp) {
+                    if (false === regexValidations.test(restfulObject[value])) {
+                        regexErrorHandler('Failed to match regex (' + regexValidations + ') for column (' + longName + ')');
+                        throw Error('Failed to match regex (' + regexValidations + ') for column (' + longName + ')');
+                    }
+                }
+                else if (typeof regexValidations === 'object' && regexValidations !== null) {
+                    (_a = Object.keys(regexValidations)) === null || _a === void 0 ? void 0 : _a.map((errorMessage) => {
+                        const regex = regexValidations[errorMessage];
+                        if (false === regex.test(restfulObject[value])) {
+                            const devErrorMessage = 'Failed to match regex (' + regex + ') for column (' + longName + ')';
+                            regexErrorHandler(errorMessage !== null && errorMessage !== void 0 ? errorMessage : devErrorMessage);
+                            throw Error(devErrorMessage);
+                        }
+                    });
+                }
+            }
+        });
+        return true;
+    });
+    return Object.keys(payload)
+        .sort()
+        .reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: payload[key] })), {});
+}
+
+var isLocal = process.env.NODE_ENV === 'development';
+
+const isTest = process.env.JEST_WORKER_ID !== undefined || process.env.NODE_ENV === 'test';
+
+const isVerbose = process.env.REACT_APP_VERBOSE === 'true';
+
+const toastOptions = {
+    position: "bottom-left",
+    autoClose: 10000,
+    hideProgressBar: false,
+    closeOnClick: true,
+    pauseOnHover: true,
+    draggable: true,
+    theme: "dark",
+};
+const toastOptionsDevs = {
+    position: "bottom-right",
+    autoClose: 3000,
+    hideProgressBar: false,
+    closeOnClick: true,
+    pauseOnHover: true,
+    draggable: true,
+    theme: "dark",
+};
+
+// todo - use bootstrap, it currently is prefixed with an underscore to denote to TS that we are aware it is unused.
+// When we capture DropExceptions and display them as a custom page, this will change.
+function TestRestfulResponse(response, success, error) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (undefined === ((_a = response.data) === null || _a === void 0 ? void 0 : _a['ERROR TYPE'])
+        && (undefined !== ((_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.rest)
+            || undefined !== ((_c = response.data) === null || _c === void 0 ? void 0 : _c.created)
+            || undefined !== ((_d = response.data) === null || _d === void 0 ? void 0 : _d.updated)
+            || undefined !== ((_e = response.data) === null || _e === void 0 ? void 0 : _e.deleted))) {
+        let successReturn = 'function' === typeof success ? success === null || success === void 0 ? void 0 : success(response) : success;
+        if (typeof successReturn === 'string') {
+            reactToastify.toast.success(successReturn, toastOptions);
+        }
+        // this could end up with bad results for deleting id's === 0
+        return (_h = (_g = (_f = response.data.created) !== null && _f !== void 0 ? _f : response.data.updated) !== null && _g !== void 0 ? _g : response.data.deleted) !== null && _h !== void 0 ? _h : true;
+    }
+    let errorReturn = 'function' === typeof error ? error === null || error === void 0 ? void 0 : error(response) : error;
+    if (typeof errorReturn === 'string') {
+        reactToastify.toast.error(errorReturn, toastOptions);
+    }
+    return false;
+}
+function removeInvalidKeys(request, c6Tables) {
+    let intersection = {};
+    let restfulObjectKeys = [];
+    c6Tables.forEach(table => Object.values(table.COLUMNS).forEach(column => {
+        if (false === restfulObjectKeys.includes(column)) {
+            restfulObjectKeys.push(column);
+        }
+    }));
+    Object.keys(request).forEach(key => {
+        if (restfulObjectKeys.includes(key)) {
+            intersection[key] = request[key];
+        }
+    });
+    isTest || console.log('intersection', intersection);
+    return intersection;
+}
+// do not remove entries from this array. It is used to track the progress of API requests.
+// position in array is important. Do not sort. To not add to begging.
+let apiRequestCache = [];
+let userCustomClearCache = [];
+function checkAllRequestsComplete() {
+    const stillRunning = apiRequestCache.filter((cache) => undefined === cache.response);
+    if (stillRunning.length !== 0) {
+        if (document === null || document === undefined) {
+            throw new Error('document is undefined while waiting for API requests to complete (' + JSON.stringify(apiRequestCache) + ')');
+        }
+        // when requests return emtpy sets in full renders, it may not be possible to track their progress.
+        console.warn('stillRunning...', stillRunning);
+        return stillRunning.map((cache) => cache.requestArgumentsSerialized);
+    }
+    return true;
+}
+function checkCache(cacheResult, requestMethod, tableName, request) {
+    var _a, _b, _c;
+    if (undefined === (cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.response)) {
+        console.groupCollapsed('%c API: The request on (' + tableName + ') is in cache and the response is undefined. The request has not finished. Returning the request Promise!', 'color: #0c0');
+        console.log('%c ' + requestMethod + ' ' + tableName, 'color: #0c0');
+        console.log('%c Request Data (note you may see the success and/or error prompt):', 'color: #0c0', request);
+        console.groupEnd();
+        return cacheResult.request;
+    }
+    if (true === (cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.final)) {
+        if (false === isTest || true === isVerbose) {
+            console.groupCollapsed('%c API: rest api cache has reached the final result. Returning undefined!', 'color: #cc0');
+            console.log('%c ' + requestMethod + ' ' + tableName, 'color: #cc0');
+            console.log('%c Request Data (note you may see the success and/or error prompt):', 'color: #cc0', request);
+            console.log('%c Response Data:', 'color: #cc0', ((_b = (_a = cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.rest) || ((_c = cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.response) === null || _c === void 0 ? void 0 : _c.data) || (cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.response));
+            console.groupEnd();
+        }
+        return undefined;
+    }
+    return false;
+}
+function sortAndSerializeQueryObject(tables, query) {
+    const orderedQuery = Object.keys(query).sort().reduce((obj, key) => {
+        obj[key] = query[key];
+        return obj;
+    }, {});
+    return tables + ' ' + JSON.stringify(orderedQuery);
+}
+function clearCache(props) {
+    if (false === (props === null || props === void 0 ? void 0 : props.ignoreWarning)) {
+        console.warn('The rest api clearCache should only be used with extreme care! Avoid using this in favor of using `cacheResults : boolean`.');
+    }
+    userCustomClearCache.map((f) => 'function' === typeof f && f());
+    userCustomClearCache = apiRequestCache = [];
+}
+/**
+ * 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.
+ **/
+const POST = 'POST';
+const PUT = 'PUT';
+const GET = 'GET';
+const DELETE = 'DELETE';
+function isPromise(x) {
+    return Object(x).constructor === Promise;
+}
+function extendedTypeHints() {
+    return (argv) => restApi(argv);
+}
+function restApi({ C6, axios, restURL, tableName, requestMethod = GET, queryCallback = {}, responseCallback, skipPrimaryCheck = false, clearCache = undefined }) {
+    const fullTableList = Array.isArray(tableName) ? tableName : [tableName];
+    const operatingTable = fullTableList[0];
+    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;
+    }
+    return (request = {}) => {
+        // an undefined query would indicate queryCallback returned undefined,
+        // thus the request shouldn't fire as is in custom cache
+        let query;
+        if ('function' === typeof queryCallback) {
+            query = queryCallback(request); // obj or obj[]
+        }
+        else {
+            query = queryCallback;
+        }
+        if (undefined === query || null === query) {
+            if (request.debug && isLocal) {
+                reactToastify.toast.warning("DEV: queryCallback returned undefined, signaling in Custom Cache. (returning null)", toastOptionsDevs);
+            }
+            console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + operatingTable + ') undefined, returning null (will not fire ajax)!', 'color: #c00');
+            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;
+        }
+        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 could return itself with a new page number, or undefined if the end is reached
+        function apiRequest() {
+            var _a, _b, _c, _d, _e, _f, _g;
+            (_a = request.cacheResults) !== null && _a !== void 0 ? _a : (request.cacheResults = C6.GET === requestMethod);
+            if (C6.GET === requestMethod
+                && undefined !== ((_b = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _b === void 0 ? void 0 : _b[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):', 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 !== null && query !== void 0 ? 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 === 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 === request.cacheResults) {
+                    // just find the next, non-fetched, page and return a function to request it
+                    if (undefined !== cacheResult) {
+                        do {
+                            const cacheCheck = checkCache(cacheResult, requestMethod, tableName, request);
+                            if (false !== cacheCheck) {
+                                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(cache => cache.requestArgumentsSerialized === querySerialized);
+                        } while (undefined !== cacheResult);
+                        if (request.debug && isLocal) {
+                            reactToastify.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 (request.debug && isLocal) {
+                        reactToastify.toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
+                    }
+                }
+                if (request.debug && isLocal) {
+                    reactToastify.toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? "Page (" + query[C6.PAGINATION][C6.PAGE] + ")." : '') + " Logging cache 2 console.", toastOptionsDevs);
+                }
+            }
+            else if (request.cacheResults) { // if we are not getting, we are updating, deleting, or inserting
+                if (cacheResult) {
+                    const cacheCheck = checkCache(cacheResult, requestMethod, tableName, request);
+                    if (false !== cacheCheck) {
+                        return cacheCheck;
+                    }
+                }
+                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 = (_f = (_e = (_d = structuredClone((_c = TABLES[operatingTable]) === null || _c === void 0 ? void 0 : _c.PRIMARY)) === null || _d === void 0 ? void 0 : _d.pop()) === null || _e === void 0 ? void 0 : _e.split('.')) === null || _f === void 0 ? void 0 : _f.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(' + JSON.stringify(query) + JSON.stringify(primaryKey) + ')' + JSON.stringify((_g = TABLES[operatingTable]) === null || _g === void 0 ? void 0 : _g.PRIMARY) + ' for table (' + operatingTable + ').');
+                    }
+                }
+                else {
+                    if (undefined === query
+                        || null === query
+                        || false === primaryKey in query) {
+                        if (true === request.debug && isLocal) {
+                            reactToastify.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(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])) {
+                        reactToastify.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.');
+                    }
+                }
+            }
+            // todo - remove
+            if (undefined !== query
+                && null !== query
+                && undefined !== primaryKey
+                && primaryKey in query) {
+                restRequestUri += query[primaryKey] + '/';
+                const removedPkValue = query[primaryKey];
+                addBackPK = () => {
+                    query !== null && query !== void 0 ? query : (query = {});
+                    query[primaryKey] = removedPkValue;
+                };
+                delete query[primaryKey];
+            }
+            try {
+                console.groupCollapsed('%c API: (' + requestMethod + ') Request Query for (' + operatingTable + ') is about to fire, will return with promise!', 'color: #A020F0');
+                console.log(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();
+                const axiosActiveRequest = axios[requestMethod.toLowerCase()](restRequestUri, (() => {
+                    // 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
+                    if (requestMethod === GET) {
+                        return {
+                            params: query
+                        };
+                    }
+                    else if (requestMethod === POST) {
+                        if (undefined !== (request === null || request === void 0 ? void 0 : request.dataInsertMultipleRows)) {
+                            return request.dataInsertMultipleRows.map(data => convertForRequestBody(data, fullTableList, (message) => reactToastify.toast.error(message, toastOptions)));
+                        }
+                        return convertForRequestBody(query, fullTableList, (message) => reactToastify.toast.error(message, toastOptions));
+                    }
+                    else if (requestMethod === PUT) {
+                        return convertForRequestBody(query, fullTableList, (message) => reactToastify.toast.error(message, toastOptions));
+                    }
+                    else if (requestMethod === DELETE) {
+                        return {
+                            data: convertForRequestBody(query, fullTableList, (message) => reactToastify.toast.error(message, toastOptions))
+                        };
+                    }
+                    else {
+                        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
+                    });
+                }
+                // https://rapidapi.com/guides/axios-async-await
+                return axiosActiveRequest.then(response => {
+                    var _a, _b, _c, _d, _e, _f, _g, _h;
+                    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);
+                    }
+                    apiResponse = TestRestfulResponse(response, request === null || request === void 0 ? void 0 : request.success, (_a = request === null || request === void 0 ? void 0 : request.error) !== null && _a !== void 0 ? _a : "An unexpected API error occurred!");
+                    if (false !== apiResponse) {
+                        responseCallback(response, request, apiResponse);
+                        if (C6.GET === requestMethod) {
+                            const responseData = response.data;
+                            // @ts-ignore
+                            returnGetNextPageFunction = 1 !== ((_b = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _b === void 0 ? void 0 : _b[C6.LIMIT]) &&
+                                ((_c = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _c === void 0 ? void 0 : _c[C6.LIMIT]) === responseData.rest.length;
+                            if (false === isTest || true === isVerbose) {
+                                console.groupCollapsed('%c API: Response returned length (' + ((_d = responseData.rest) === null || _d === void 0 ? void 0 : _d.length) + ') of possible (' + ((_e = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _e === void 0 ? void 0 : _e[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', request);
+                                console.log('%c Response Data:', 'color: #0c0', responseData.rest);
+                                console.log('%c Will return get next page function:' + (1 !== ((_f = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _f === void 0 ? void 0 : _f[C6.LIMIT]) ? '' : ' (Will not return with explicit limit 1 set)'), 'color: #0c0', true === returnGetNextPageFunction);
+                                console.trace();
+                                console.groupEnd();
+                            }
+                            if (false === returnGetNextPageFunction
+                                && true === request.debug
+                                && isLocal) {
+                                reactToastify.toast.success("DEVS: Response returned length (" + ((_g = responseData.rest) === null || _g === void 0 ? void 0 : _g.length) + ") less than limit (" + ((_h = query === null || query === void 0 ? void 0 : query[C6.PAGINATION]) === null || _h === void 0 ? void 0 : _h[C6.LIMIT]) + ").", toastOptionsDevs);
+                            }
+                        }
+                    }
+                    if (cachingConfirmed) {
+                        const cacheIndex = apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized);
+                        apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction;
+                        // only cache get method requests
+                        apiRequestCache[cacheIndex].response = response;
+                    }
+                    if (request.debug && isLocal) {
+                        reactToastify.toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
+                    }
+                    return response;
+                });
+            }
+            catch (error) {
+                if (isTest) {
+                    throw new Error(JSON.stringify(error));
+                }
+                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(error);
+                console.trace();
+                console.groupEnd();
+                TestRestfulResponse(error, request === null || request === void 0 ? void 0 : request.success, (request === null || request === void 0 ? void 0 : request.error) || "An restful API error occurred!");
+                return null;
+            }
+        }
+        return apiRequest();
+    };
+}
+
+exports.C6 = C6;
+exports.DELETE = DELETE;
+exports.GET = GET;
+exports.POST = POST;
+exports.PUT = PUT;
+exports.TestRestfulResponse = TestRestfulResponse;
+exports.checkAllRequestsComplete = checkAllRequestsComplete;
+exports.clearCache = clearCache;
+exports.convertForRequestBody = convertForRequestBody;
+exports.extendedTypeHints = extendedTypeHints;
+exports.isLocal = isLocal;
+exports.isPromise = isPromise;
+exports.isTest = isTest;
+exports.isVerbose = isVerbose;
+exports.removeInvalidKeys = removeInvalidKeys;
+exports.restRequest = restApi;
+exports.toastOptions = toastOptions;
+exports.toastOptionsDevs = toastOptionsDevs;