@carbonorm/carbonnode 3.0.2 → 3.0.4

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,31 +316,33 @@ 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) {
+    return {
+        Get: restRequest(__assign(__assign({}, config), { requestMethod: "GET" })),
+        Put: restRequest(__assign(__assign({}, config), { requestMethod: "PUT" })),
+        Post: restRequest(__assign(__assign({}, config), { requestMethod: "POST" })),
+        Delete: restRequest(__assign(__assign({}, config), { requestMethod: "DELETE" })),
     };
 }
 
@@ -512,15 +519,6 @@ function buildSelectQuery(table, primary, args, isSubSelect) {
     return sql;
 }
 
-var Executor = /** @class */ (function () {
-    function Executor(config, request) {
-        if (request === void 0) { request = {}; }
-        this.config = config;
-        this.request = request;
-    }
-    return Executor;
-}());
-
 function getEnvVar(key, fallback) {
     if (fallback === void 0) { fallback = ''; }
     // Vite-style injection
@@ -536,15 +534,67 @@ function getEnvVar(key, fallback) {
     return fallback;
 }
 
+var envVerbose = getEnvVar('VERBOSE') || getEnvVar('REACT_APP_VERBOSE') || getEnvVar('VITE_VERBOSE') || '';
+var isVerbose = ['true', '1', 'yes', 'on'].includes(envVerbose.toLowerCase());
+
+var Executor = /** @class */ (function () {
+    function Executor(config, request) {
+        this.config = config;
+        this.request = request;
+    }
+    Executor.prototype.runLifecycleHooks = function (phase, args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lifecycleGroup, _i, _a, _b, key, fn, err_1;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        lifecycleGroup = (_c = this.config.restModel.LIFECYCLE_HOOKS[this.config.requestMethod]) === null || _c === void 0 ? void 0 : _c[phase];
+                        if (!lifecycleGroup)
+                            return [2 /*return*/];
+                        _i = 0, _a = Object.entries(lifecycleGroup);
+                        _d.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 6];
+                        _b = _a[_i], key = _b[0], fn = _b[1];
+                        if (!(typeof fn === "function")) return [3 /*break*/, 5];
+                        if (isVerbose || args.request.debug) {
+                            console.groupCollapsed("[LIFECYCLE] ".concat(this.config.requestMethod, ".").concat(String(phase), ":").concat(key));
+                            console.log("config:", args.config);
+                            console.log("request:", args.request);
+                            if ("response" in args) {
+                                console.log("response:", args.response);
+                            }
+                            console.groupEnd();
+                        }
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, fn(args)];
+                    case 3:
+                        _d.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _d.sent();
+                        console.error("[LIFECYCLE ERROR] ".concat(this.config.requestMethod, ".").concat(String(phase), ":").concat(key), err_1);
+                        throw err_1;
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Executor;
+}());
+
 var isDevelopment = getEnvVar('NODE_ENV', '') === 'development';
 
 var isTest = getEnvVar('JEST_WORKER_ID') || getEnvVar('NODE_ENV') === 'test'
     || getEnvVar('REACT_APP_TEST') === 'true' || getEnvVar('VITE_TEST') === 'true'
     || getEnvVar('MODE') === 'test' || getEnvVar('VITE_TEST_MODE') === 'true';
 
-var envVerbose = getEnvVar('VERBOSE') || getEnvVar('REACT_APP_VERBOSE') || getEnvVar('VITE_VERBOSE') || '';
-var isVerbose = ['true', '1', 'yes', 'on'].includes(envVerbose.toLowerCase());
-
 var eFetchDependencies;
 (function (eFetchDependencies) {
     eFetchDependencies[eFetchDependencies["NONE"] = 0] = "NONE";
@@ -557,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",
@@ -685,14 +723,68 @@ var HttpExecutor = /** @class */ (function (_super) {
     function HttpExecutor() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    HttpExecutor.prototype.putState = function (response, request, callback) {
+        var _a, _b;
+        (_a = this.config.reactBootstrap) === null || _a === void 0 ? void 0 : _a.updateRestfulObjectArrays({
+            callback: callback,
+            dataOrCallback: [
+                removeInvalidKeys(__assign(__assign({}, request), (_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.rest), this.config.C6.TABLES)
+            ],
+            stateKey: this.config.restModel.TABLE_NAME,
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT
+        });
+    };
+    HttpExecutor.prototype.postState = function (response, request, callback) {
+        var _this = this;
+        var _a, _b, _c;
+        if (1 !== this.config.restModel.PRIMARY_SHORT.length) {
+            console.error("C6 received unexpected result's given the primary key length");
+        }
+        else {
+            var pk = this.config.restModel.PRIMARY_SHORT[0];
+            // TODO - should overrides be handled differently? Why override: (react/php), driver missmatches, aux data..
+            // @ts-ignore - this is technically a correct error, but we allow it anyway...
+            request[pk] = (_a = response.data) === null || _a === void 0 ? void 0 : _a.created;
+        }
+        (_b = this.config.reactBootstrap) === null || _b === void 0 ? void 0 : _b.updateRestfulObjectArrays({
+            callback: callback,
+            dataOrCallback: undefined !== request.dataInsertMultipleRows
+                ? request.dataInsertMultipleRows.map(function (request, index) {
+                    var _a;
+                    return removeInvalidKeys(__assign(__assign({}, request), (index === 0 ? (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.rest : {})), _this.config.C6.TABLES);
+                })
+                : [
+                    removeInvalidKeys(__assign(__assign({}, request), (_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.rest), this.config.C6.TABLES)
+                ],
+            stateKey: this.config.restModel.TABLE_NAME,
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT
+        });
+    };
+    HttpExecutor.prototype.deleteState = function (_response, request, callback) {
+        var _a;
+        (_a = this.config.reactBootstrap) === null || _a === void 0 ? void 0 : _a.deleteRestfulObjectArrays({
+            callback: callback,
+            dataOrCallback: [
+                request,
+            ],
+            stateKey: this.config.restModel.TABLE_NAME,
+            uniqueObjectId: this.config.restModel.PRIMARY_SHORT
+        });
+    };
     HttpExecutor.prototype.execute = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, C6, axios, restURL, withCredentials, restModel, requestMethod, queryCallback, responseCallback, skipPrimaryCheck, clearCache, tableName, fullTableList, operatingTableFullName, operatingTable, tables, query, apiRequest;
+            var _a, C6, axios, restURL, withCredentials, restModel, reactBootstrap, requestMethod, skipPrimaryCheck, clearCache, tableName, fullTableList, operatingTableFullName, operatingTable, tables, query, apiRequest;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        _a = this.config, C6 = _a.C6, axios = _a.axios, restURL = _a.restURL, withCredentials = _a.withCredentials, restModel = _a.restModel, requestMethod = _a.requestMethod, queryCallback = _a.queryCallback, responseCallback = _a.responseCallback, skipPrimaryCheck = _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,
+                            })];
+                    case 1:
+                        _b.sent();
                         tableName = restModel.TABLE_NAME;
                         fullTableList = Array.isArray(tableName) ? tableName : [tableName];
                         operatingTableFullName = fullTableList[0];
@@ -713,22 +805,16 @@ var HttpExecutor = /** @class */ (function (_super) {
                         console.groupCollapsed('%c API: (' + requestMethod + ') Request for (' + tableName + ')', 'color: #0c0');
                         console.log('request', this.request);
                         console.groupEnd();
-                        if ('function' === typeof queryCallback) {
-                            query = queryCallback(this.request); // obj or obj[]
-                        }
-                        else {
-                            query = queryCallback;
-                        }
-                        if (undefined === query || null === query) {
-                            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('%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] = {};
@@ -866,51 +952,36 @@ var HttpExecutor = /** @class */ (function (_super) {
                                     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();
-                                    axiosActiveRequest = (_e = axios)[requestMethod.toLowerCase()].apply(_e, __spreadArray([restRequestUri], ((function () {
-                                        // @link - https://axios-http.com/docs/instance
-                                        // How configuration vs data is passed is variable, use documentation above for reference
-                                        if (requestMethod === GET) {
-                                            return [{
-                                                    withCredentials: withCredentials,
-                                                    params: query
-                                                }];
-                                        }
-                                        else if (requestMethod === POST) {
-                                            if (undefined !== dataInsertMultipleRows) {
-                                                return [
-                                                    dataInsertMultipleRows.map(function (data) {
-                                                        return convertForRequestBody(data, fullTableList, C6, function (message) { return toast.error(message, toastOptions); });
-                                                    }),
-                                                    {
-                                                        withCredentials: withCredentials,
-                                                    }
-                                                ];
-                                            }
-                                            return [
-                                                convertForRequestBody(query, fullTableList, C6, function (message) { return toast.error(message, toastOptions); }),
-                                                {
-                                                    withCredentials: withCredentials,
-                                                }
-                                            ];
-                                        }
-                                        else if (requestMethod === PUT) {
-                                            return [
-                                                convertForRequestBody(query, fullTableList, C6, function (message) { return toast.error(message, toastOptions); }),
-                                                {
-                                                    withCredentials: withCredentials,
+                                    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."));
                                         }
-                                        else if (requestMethod === DELETE) {
-                                            return [{
-                                                    withCredentials: withCredentials,
-                                                    data: convertForRequestBody(query, fullTableList, C6, function (message) { return toast.error(message, toastOptions); })
-                                                }];
-                                        }
-                                        else {
-                                            throw new Error('The request method (' + requestMethod + ') was not recognized.');
-                                        }
-                                    })()), false));
+                                    })(), false));
                                     if (cachingConfirmed) {
                                         // push to cache so we do not repeat the request
                                         apiRequestCache.push({
@@ -924,12 +995,13 @@ var HttpExecutor = /** @class */ (function (_super) {
                                     // 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, responseData_1, dependencies_1, fetchReferences_1, apiRequestPromises, _loop_1, _a, _b, _c, _i, tableToFetch;
+                                            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();
@@ -943,6 +1015,12 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                             // 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) {
@@ -950,9 +1028,34 @@ var HttpExecutor = /** @class */ (function (_super) {
                                                             }
                                                             return [2 /*return*/, response];
                                                         }
-                                                        // stateful operations are done in the response callback - its leverages rest generated functions
-                                                        if (responseCallback) {
-                                                            responseCallback(response, this.request, apiResponse);
+                                                        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;
@@ -1178,7 +1281,7 @@ var HttpExecutor = /** @class */ (function (_super) {
                             });
                         }); };
                         return [4 /*yield*/, apiRequest()];
-                    case 1: return [2 /*return*/, _b.sent()];
+                    case 2: return [2 /*return*/, _b.sent()];
                 }
             });
         });
@@ -1446,5 +1549,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, 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