@carbonorm/carbonnode 3.11.0 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonorm/carbonnode",
-  "version": "3.11.0",
+  "version": "4.0.0",
   "browser": "dist/index.umd.js",
   "repository": {
     "type": "git",

package/src/__tests__/cacheManager.test.ts

@@ -0,0 +1,67 @@
+import type { AxiosPromise } from "axios";
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  apiRequestCache,
+  checkCache,
+  clearCache,
+  setCache,
+} from "../api/utils/cacheManager";
+import { checkAllRequestsComplete } from "../api/utils/testHelpers";
+
+describe("cacheManager with map storage", () => {
+  const requestData = { id: 1 } as const;
+
+  beforeEach(() => {
+    clearCache({ ignoreWarning: true });
+  });
+
+  it("stores and returns cached requests", () => {
+    const mockRequest = Promise.resolve({ data: { rest: [] } }) as AxiosPromise;
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "serialized",
+      request: mockRequest,
+    });
+
+    const cached = checkCache("GET", "table", { ...requestData });
+    expect(cached).toBe(mockRequest);
+  });
+
+  it("clears cache entries", () => {
+    const mockRequest = Promise.resolve({ data: { rest: [] } }) as AxiosPromise;
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "serialized",
+      request: mockRequest,
+    });
+
+    clearCache({ ignoreWarning: true });
+
+    expect(apiRequestCache.size).toBe(0);
+    expect(checkCache("GET", "table", requestData)).toBe(false);
+  });
+
+  it("reports pending and completed requests via helper", () => {
+    const originalDocument = (global as any).document;
+    (global as any).document = {};
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "pending",
+      request: Promise.resolve({ data: null }) as AxiosPromise,
+    });
+
+    expect(checkAllRequestsComplete()).toEqual(["pending"]);
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "pending",
+      request: Promise.resolve({ data: null }) as AxiosPromise,
+      response: {} as any,
+      final: true,
+    });
+
+    expect(checkAllRequestsComplete()).toBe(true);
+
+    (global as any).document = originalDocument;
+  });
+});
+

package/src/__tests__/expressServer.e2e.test.ts

@@ -2,7 +2,7 @@ import mysql from "mysql2/promise";
 import axios from "axios";
 import { AddressInfo } from "net";
 import {describe, it, expect, beforeAll, afterAll} from "vitest";
-import {Actor, C6, GLOBAL_REST_PARAMETERS} from "./sakila-db/C6.js";
+import {Actor, C6, Film_Actor, GLOBAL_REST_PARAMETERS} from "./sakila-db/C6.js";
 import {C6C} from "../api/C6Constants";
 import createTestServer from "./fixtures/createTestServer";
 
@@ -23,7 +23,12 @@ beforeAll(async () => {
     const {port} = server.address() as AddressInfo;
 
     GLOBAL_REST_PARAMETERS.restURL = `http://127.0.0.1:${port}/rest/`;
-    GLOBAL_REST_PARAMETERS.axios = axios;
+    const axiosClient = axios.create();
+    axiosClient.interceptors.response.use(
+        response => response,
+        error => Promise.reject(new Error(error?.message ?? 'Request failed')),
+    );
+    GLOBAL_REST_PARAMETERS.axios = axiosClient;
     GLOBAL_REST_PARAMETERS.verbose = false;
     // ensure HTTP executor is used
     // @ts-ignore
@@ -93,6 +98,79 @@ describe("ExpressHandler e2e", () => {
         expect(data?.rest.length).toBe(0);
     });
 
+    it("stringifies plain object values in PUT updates", async () => {
+        const first_name = `Json${Date.now()}`;
+        const last_name = `User${Date.now()}`;
+
+        await Actor.Post({
+            first_name,
+            last_name,
+        } as any);
+
+        const payload = { greeting: "hello", flags: [1, true] };
+
+        let data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+            [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+        } as any);
+
+        const actorId = data?.rest?.[0]?.actor_id;
+        expect(actorId).toBeTruthy();
+
+        await Actor.Put({
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+            [C6C.UPDATE]: { first_name: payload },
+        } as any);
+
+        data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+        } as any);
+
+        expect(data?.rest?.[0]?.first_name).toBe(JSON.stringify(payload));
+    });
+
+    it("rejects operator-like objects in PUT updates", async () => {
+        const first_name = `Invalid${Date.now()}`;
+        const last_name = `User${Date.now()}`;
+
+        await Actor.Post({
+            first_name,
+            last_name,
+        } as any);
+
+        const data = await Actor.Get({
+            [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+            [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+        } as any);
+
+        const actorId = data?.rest?.[0]?.actor_id;
+        expect(actorId).toBeTruthy();
+
+        const operatorLike = { [C6C.GREATER_THAN]: "oops" } as any;
+
+        const prevRestUrl = GLOBAL_REST_PARAMETERS.restURL;
+        const prevAxios = GLOBAL_REST_PARAMETERS.axios;
+        GLOBAL_REST_PARAMETERS.mysqlPool = pool as any;
+        delete (GLOBAL_REST_PARAMETERS as any).restURL;
+        delete (GLOBAL_REST_PARAMETERS as any).axios;
+
+        try {
+            await Actor.Put({
+                [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+                [C6C.UPDATE]: { first_name: operatorLike },
+            } as any);
+            throw new Error('Expected PUT to reject for operator-like payload.');
+        } catch (error: any) {
+            const message = String(error?.message ?? error);
+            expect(message).toMatch(/operand/i);
+        } finally {
+            GLOBAL_REST_PARAMETERS.restURL = prevRestUrl;
+            GLOBAL_REST_PARAMETERS.axios = prevAxios;
+            // @ts-ignore
+            delete GLOBAL_REST_PARAMETERS.mysqlPool;
+        }
+    });
+
     it("respects METHOD=GET override on POST", async () => {
         const {restURL} = GLOBAL_REST_PARAMETERS;
         const table = Actor.TABLE_NAME;
@@ -121,4 +199,28 @@ describe("ExpressHandler e2e", () => {
         expect(response.status).toBe(200);
         expect(response.data?.success).toBeTruthy();
     });
+
+    it("allows composite keys when a URL primary is present", async () => {
+        const {restURL} = GLOBAL_REST_PARAMETERS;
+        const table = Film_Actor.TABLE_NAME;
+
+        const seed = await Film_Actor.Get({
+            [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+        } as any);
+
+        const filmActor = seed.rest[0];
+        expect(filmActor).toBeTruthy();
+
+        const response = await axios.post(`${restURL}${table}/${filmActor.actor_id}?METHOD=GET`, {
+            [C6C.WHERE]: {
+                [Film_Actor.ACTOR_ID]: filmActor.actor_id,
+                [Film_Actor.FILM_ID]: filmActor.film_id,
+            },
+        });
+
+        expect(response.status).toBe(200);
+        expect(response.data?.rest).toHaveLength(1);
+        expect(response.data?.rest?.[0]?.actor_id).toBe(filmActor.actor_id);
+        expect(response.data?.rest?.[0]?.film_id).toBe(filmActor.film_id);
+    });
 });

package/src/__tests__/fixtures/c6.fixture.ts

@@ -43,6 +43,7 @@ export function buildTestConfig() {
     'actor.first_name': 'first_name',
     'actor.last_name': 'last_name',
     'actor.binarycol': 'binarycol',
+    'actor.json_data': 'json_data',
   } as const;
 
   const filmActorCols = {
@@ -62,6 +63,7 @@ export function buildTestConfig() {
 
   // Special-case: mark binary column as BINARY to test conversion
   C6.TABLES.actor.TYPE_VALIDATION['binarycol'].MYSQL_TYPE = 'BINARY(16)';
+  C6.TABLES.actor.TYPE_VALIDATION['json_data'].MYSQL_TYPE = 'JSON';
 
   const baseConfig: iRest<any, any, any> = {
     C6,

package/src/__tests__/httpExecutorSingular.e2e.test.ts

@@ -23,7 +23,12 @@ beforeAll(async () => {
   const { port } = server.address() as AddressInfo;
 
   GLOBAL_REST_PARAMETERS.restURL = `http://127.0.0.1:${port}/rest/`;
-  GLOBAL_REST_PARAMETERS.axios = axios;
+  const axiosClient = axios.create();
+  axiosClient.interceptors.response.use(
+    response => response,
+    error => Promise.reject(new Error(error?.message ?? "Request failed")),
+  );
+  GLOBAL_REST_PARAMETERS.axios = axiosClient;
   GLOBAL_REST_PARAMETERS.verbose = false;
   // ensure HTTP executor is used
   // @ts-ignore
@@ -41,14 +46,14 @@ describe("HttpExecutor singular e2e", () => {
     const last_name = `User${Date.now()}`;
 
     // POST
-    const postRes = await Actor.Post({ first_name, last_name } as any);
-    expect(postRes.affected).toBe(1);
+    await Actor.Post({ first_name, last_name } as any);
 
     // Fetch inserted id using complex query
     let data = await Actor.Get({
       [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
       [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
-    } as any);
+    });
+
     expect(data.rest).toHaveLength(1);
     const testId = data.rest[0].actor_id;
 
@@ -89,4 +94,30 @@ describe("HttpExecutor singular e2e", () => {
     expect(Array.isArray(data.rest)).toBe(true);
     expect(data.rest.length).toBe(0);
   });
+
+  it("exposes next when pagination continues", async () => {
+    const data = await Actor.Get({
+      [C6C.PAGINATION]: { [C6C.LIMIT]: 2 },
+    } as any);
+
+    expect(Array.isArray(data.rest)).toBe(true);
+    expect(data.rest).toHaveLength(2);
+    expect(typeof data.next).toBe("function");
+
+    const nextPage = await data.next?.();
+    expect(nextPage?.rest).toBeDefined();
+    expect(Array.isArray(nextPage?.rest)).toBe(true);
+    expect(nextPage?.rest?.length).toBeGreaterThan(0);
+  });
+
+  it("exposes limit 1 does not expose next", async () => {
+    const data = await Actor.Get({
+      [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+    } as any);
+
+    expect(Array.isArray(data.rest)).toBe(true);
+    expect(data.rest).toHaveLength(1);
+    expect(typeof data.next).toBe("undefined");
+
+  });
 });

package/src/__tests__/sakila-db/C6.js

@@ -1342,7 +1342,7 @@ export const TABLES = {
 };
 export const C6 = {
     ...C6Constants,
-    C6VERSION: '3.11.0',
+    C6VERSION: '4.0.0',
     IMPORT: async (tableName) => {
         tableName = tableName.toLowerCase();
         // if tableName is not a key in the TABLES object then throw an error

package/src/__tests__/sakila-db/C6.ts

@@ -2009,7 +2009,7 @@ export type RestTableInterfaces = iActor
 
 export const C6 : iC6Object<RestTableInterfaces> = {
     ...C6Constants,
-    C6VERSION: '3.11.0',
+    C6VERSION: '4.0.0',
     IMPORT: async (tableName: string) : Promise<iDynamicApiImport> => {
 
         tableName = tableName.toLowerCase();

package/src/__tests__/sqlBuilders.test.ts

@@ -61,6 +61,34 @@ describe('SQL Builders', () => {
     expect(params).toEqual(['BOB', 'SMITH']);
   });
 
+  it('stringifies plain object inserts for JSON columns', () => {
+    const config = buildTestConfig();
+    const payload = { hello: 'world', nested: { ok: true } };
+    const qb = new PostQueryBuilder(config as any, {
+      [C6C.INSERT]: {
+        'actor.json_data': payload,
+      },
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+
+    expect(sql).toContain('`json_data`');
+    expect(params).toEqual([JSON.stringify(payload)]);
+  });
+
+  it('throws on operator-shaped insert payloads', () => {
+    const config = buildTestConfig();
+    const qb = new PostQueryBuilder(config as any, {
+      [C6C.INSERT]: {
+        'actor.first_name': {
+          [C6C.GREATER_THAN]: 'ALICE',
+        },
+      },
+    } as any, false);
+
+    expect(() => qb.build('actor')).toThrowError(/requires two operands/);
+  });
+
   it('builds UPDATE with WHERE and pagination', () => {
     const config = buildTestConfig();
     const qb = new UpdateQueryBuilder(config as any, {

package/src/api/axiosInstance.ts

@@ -151,7 +151,36 @@ axiosInstance.interceptors.request.use((config) => {
         }
     }
 
+    (config as any).__carbonStart = performance.now();
+
     return config;
 });
 
+
+axiosInstance.interceptors.response.use(
+    (response) => {
+        const end = performance.now();
+        const start = (response.config as any).__carbonStart;
+        (response as any).__carbonTiming = {
+            start,
+            end,
+            duration: end - start,
+        };
+        return response;
+    },
+    (error) => {
+        if (error.config) {
+            const end = performance.now();
+            const start = (error.config as any).__carbonStart;
+            (error as any).__carbonTiming = {
+                start,
+                end,
+                duration: end - start,
+            };
+        }
+        throw error;
+    }
+);
+
+
 export default axiosInstance

package/src/api/executors/HttpExecutor.ts

@@ -8,14 +8,13 @@ import {OrmGenerics} from "../types/ormGenerics";
 import {
     DELETE, DetermineResponseDataType,
     GET,
-    iCacheAPI,
     iConstraint,
-    iGetC6RestResponse,
+    C6RestResponse,
     POST,
     PUT, RequestQueryBody
 } from "../types/ormInterfaces";
 import {removeInvalidKeys, removePrefixIfExists, TestRestfulResponse} from "../utils/apiHelpers";
-import {apiRequestCache, checkCache, userCustomClearCache} from "../utils/cacheManager";
+import {checkCache, setCache, userCustomClearCache} from "../utils/cacheManager";
 import {sortAndSerializeQueryObject} from "../utils/sortAndSerializeQueryObject";
 import {Executor} from "./Executor";
 import {toastOptions, toastOptionsDevs} from "variables/toastOptions";
@@ -27,8 +26,11 @@ export class HttpExecutor<
 
     private isRestResponse<T extends Record<string, any>>(
         r: AxiosResponse<any>
-    ): r is AxiosResponse<iGetC6RestResponse<T>> {
-        return !!r && r.data != null && typeof r.data === 'object' && 'rest' in r.data;
+    ): r is AxiosResponse<C6RestResponse<'GET', T>> {
+        return !!r
+            && r.data != null
+            && typeof r.data === 'object'
+            && Array.isArray((r.data as C6RestResponse<'GET', T>).rest);
     }
 
     private stripTableNameFromKeys<T extends Record<string, any>>(obj: Partial<T> | undefined | null): Partial<T> {
@@ -182,20 +184,6 @@ export class HttpExecutor<
             console.groupEnd()
         }
 
-        // an undefined query would indicate queryCallback returned undefined,
-        // thus the request shouldn't fire as is in custom cache
-        if (undefined === this.request || null === this.request) {
-
-            if (isLocal()) {
-                console.groupCollapsed(`API: (${requestMethod}) (${tableName}) query undefined/null → returning null`)
-                console.log('request', this.request)
-                console.groupEnd()
-            }
-
-            return null;
-
-        }
-
         let query = this.request;
 
         // this is parameterless and could return itself with a new page number, or undefined if the end is reached
@@ -219,14 +207,6 @@ export class HttpExecutor<
                 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: string = sortAndSerializeQueryObject(tables, query ?? {});
-
-            let cacheResult: iCacheAPI | undefined = apiRequestCache.find(cache => cache.requestArgumentsSerialized === querySerialized);
-
             let cachingConfirmed = false;
 
             // determine if we need to paginate.
@@ -253,52 +233,42 @@ export class HttpExecutor<
 
                 query[C6.PAGINATION][C6.LIMIT] = query[C6.PAGINATION][C6.LIMIT] || 100;
 
-                // this will evaluate true most the time
-                if (true === cacheResults) {
-                    if (undefined !== cacheResult) {
-                        do {
-                            const cacheCheck = checkCache<ResponseDataType>(cacheResult, requestMethod, tableName, this.request);
-                            if (false !== cacheCheck) {
-                                return (await cacheCheck).data;
-                            }
-                            ++query[C6.PAGINATION][C6.PAGE];
-                            querySerialized = sortAndSerializeQueryObject(tables, query ?? {});
-                            cacheResult = apiRequestCache.find(cache => cache.requestArgumentsSerialized === querySerialized)
-                        } while (undefined !== cacheResult)
-                        if (debug && isLocal()) {
-                            toast.warning("DEVS: Request pages exhausted in cache; firing network.", toastOptionsDevs);
-                        }
-                    }
-                    cachingConfirmed = true;
-                } else {
-                    if (debug && isLocal()) toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
-                }
-
-                if (debug && isLocal()) {
-                    toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? " Page (" + query[C6.PAGINATION][C6.PAGE] + ")" : ''), toastOptionsDevs);
-                }
+            }
 
-            } else if (cacheResults) { // if we are not getting, we are updating, deleting, or inserting
+            // 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
+            const cacheRequestData = JSON.parse(JSON.stringify(query ?? {})) as RequestQueryBody<
+                G['RequestMethod'],
+                G['RestTableInterface'],
+                G['CustomAndRequiredFields'],
+                G['RequestTableOverrides']
+            >;
 
-                if (cacheResult) {
-                    const cacheCheck = checkCache<ResponseDataType>(cacheResult, requestMethod, tableName, this.request);
+            // literally impossible for query to be undefined or null here but the editor is too busy licking windows to understand that
+            let querySerialized: string = sortAndSerializeQueryObject(tables, cacheRequestData ?? {});
 
-                    if (false !== cacheCheck) {
+            let cachedRequest: AxiosPromise<ResponseDataType> | false = false;
 
-                        return (await cacheCheck).data;
+            if (cacheResults) {
+                cachedRequest = checkCache<ResponseDataType>(requestMethod, tableName, cacheRequestData);
+            }
 
-                    }
-                }
+            if (cachedRequest) {
+                return (await cachedRequest).data;
+            }
 
+            if (cacheResults) {
                 cachingConfirmed = true;
-                // push to cache so we do not repeat the request
+            } else if (debug && isLocal()) {
+                toast.info("DEVS: Ignore cache was set to true.", toastOptionsDevs);
+            }
 
+            if (cacheResults && debug && isLocal()) {
+                toast.success("DEVS: Request not in cache." + (requestMethod === C6.GET ? " Page (" + query[C6.PAGINATION][C6.PAGE] + ")" : ''), toastOptionsDevs);
             }
 
             let apiResponse: G['RestTableInterface'][G['PrimaryKey']] | string | boolean | number | undefined;
 
-            let returnGetNextPageFunction = false;
-
             let restRequestUri: string = restURL + operatingTable + '/';
 
             const needsConditionOrPrimaryCheck = (PUT === requestMethod || DELETE === requestMethod)
@@ -460,22 +430,30 @@ export class HttpExecutor<
 
 
                 if (cachingConfirmed) {
-
-                    // push to cache so we do not repeat the request
-                    apiRequestCache.push({
+                    setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
                         requestArgumentsSerialized: querySerialized,
-                        request: axiosActiveRequest
+                        request: axiosActiveRequest,
                     });
-
                 }
 
                 // returning the promise with this then is important for tests. todo - we could make that optional.
                 // https://rapidapi.com/guides/axios-async-await
                 return axiosActiveRequest.then(async (response: AxiosResponse<ResponseDataType, any>): Promise<AxiosResponse<ResponseDataType, any>> => {
 
+                        let hasNext: boolean | undefined;
+
                         // noinspection SuspiciousTypeOfGuard
                         if (typeof response.data === 'string') {
 
+                            if (cachingConfirmed) {
+                                setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
+                                    requestArgumentsSerialized: querySerialized,
+                                    request: axiosActiveRequest,
+                                    response,
+                                    final: true,
+                                });
+                            }
+
                             if (isTest()) {
 
                                 console.trace()
@@ -489,15 +467,11 @@ export class HttpExecutor<
                         }
 
                         if (cachingConfirmed) {
-
-                            const cacheIndex = apiRequestCache.findIndex(cache => cache.requestArgumentsSerialized === querySerialized);
-
-                            // TODO - currently nonthing is setting this correctly
-                            apiRequestCache[cacheIndex].final = false === returnGetNextPageFunction
-
-                            // only cache get method requests
-                            apiRequestCache[cacheIndex].response = response
-
+                            setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
+                                requestArgumentsSerialized: querySerialized,
+                                request: axiosActiveRequest,
+                                response,
+                            });
                         }
 
                         this.runLifecycleHooks<"afterExecution">(
@@ -549,27 +523,30 @@ export class HttpExecutor<
                             callback();
                         }
 
-                        if (C6.GET === requestMethod && this.isRestResponse<any>(response)) {
+                        if (C6.GET === requestMethod && this.isRestResponse(response)) {
 
                             const responseData = response.data;
 
                             const pageLimit = query?.[C6.PAGINATION]?.[C6.LIMIT];
+
                             const got = responseData.rest.length;
-                            const hasNext = pageLimit !== 1 && got === pageLimit;
+                            hasNext = pageLimit !== 1 && got === pageLimit;
 
                             if (hasNext) {
-                                responseData.next = apiRequest;   // there might be more
+                                responseData.next = apiRequest as () => Promise<
+                                    DetermineResponseDataType<'GET', G['RestTableInterface']>
+                                >;
                             } else {
                                 responseData.next = undefined;    // short page => done
                             }
 
-                            // If you keep this flag, make it reflect reality:
-                            returnGetNextPageFunction = hasNext;
-
-                            // and fix cache ‘final’ flag to match:
                             if (cachingConfirmed) {
-                                const cacheIndex = apiRequestCache.findIndex(c => c.requestArgumentsSerialized === querySerialized);
-                                apiRequestCache[cacheIndex].final = !hasNext;
+                                setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
+                                    requestArgumentsSerialized: querySerialized,
+                                    request: axiosActiveRequest,
+                                    response,
+                                    final: !hasNext,
+                                });
                             }
 
                             if ((this.config.verbose || debug) && isLocal()) {
@@ -580,11 +557,9 @@ export class HttpExecutor<
                             }
 
                             // next already set above based on hasNext; avoid duplicate, inverted logic
-
-
                             if (fetchDependencies
                                 && 'number' === typeof fetchDependencies
-                                && responseData.rest.length > 0) {
+                                && responseData.rest?.length > 0) {
 
                                 console.groupCollapsed('%c API: Fetch Dependencies segment (' + requestMethod + ' ' + tableName + ')'
                                     + (fetchDependencies & eFetchDependencies.CHILDREN ? ' | (CHILDREN|REFERENCED) ' : '')
@@ -827,6 +802,15 @@ export class HttpExecutor<
 
                         }
 
+                        if (cachingConfirmed && hasNext === undefined) {
+                            setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
+                                requestArgumentsSerialized: querySerialized,
+                                request: axiosActiveRequest,
+                                response,
+                                final: true,
+                            });
+                        }
+
                         if (debug && isLocal()) {
 
                             toast.success("DEVS: (" + requestMethod + ") request complete.", toastOptionsDevs);
@@ -841,25 +825,17 @@ export class HttpExecutor<
 
             } 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.error(throwableError)
 
                 console.trace()
 
                 console.groupEnd()
 
-                TestRestfulResponse(throwableError, success, error)
-
-                return null;
+                throw new Error(JSON.stringify(throwableError))
 
             }