@carbonorm/carbonnode 6.0.19 → 6.1.0

package/src/__tests__/sqlBuilders.expressions.test.ts

@@ -30,22 +30,20 @@ describe('Explicit SQL expression grammar', () => {
         [C6C.OR]: [
           {
             [C6C.LESS_THAN_OR_EQUAL_TO]: [
-              {
-                [C6C.ST_DISTANCE_SPHERE]: [
-                  Property_Units.LOCATION,
-                  { [C6C.ST_GEOMFROMTEXT]: ['POINT(39.4972468 -105.0403593)', 4326] },
-                ],
-              },
+              [
+                C6C.ST_DISTANCE_SPHERE,
+                Property_Units.LOCATION,
+                [C6C.ST_GEOMFROMTEXT, [C6C.LIT, 'POINT(39.4972468 -105.0403593)'], 4326],
+              ],
               5000,
             ],
           },
           {
             [C6C.GREATER_THAN]: [
-              {
-                [C6C.ST_AREA]: [
-                  { [C6C.ST_GEOMFROMTEXT]: ['POLYGON((0 0,1 0,1 1,0 1,0 0))', 4326] },
-                ],
-              },
+              [
+                C6C.ST_AREA,
+                [C6C.ST_GEOMFROMTEXT, [C6C.LIT, 'POLYGON((0 0,1 0,1 1,0 1,0 0))'], 4326],
+              ],
               10000,
             ],
           },
@@ -56,12 +54,17 @@ describe('Explicit SQL expression grammar', () => {
     const { sql, params } = qb.build(Property_Units.TABLE_NAME);
 
     expect(sql).toContain('WHERE');
-    expect(sql).toMatch(/ST_DISTANCE_SPHERE\(property_units.location, ST_GEOMFROMTEXT\('/);
-    expect(sql).toMatch(/ST_AREA\(ST_GEOMFROMTEXT\('/);
+    expect(sql).toMatch(/ST_DISTANCE_SPHERE\(property_units.location, ST_GEOMFROMTEXT\(\?, 4326\)\)/);
+    expect(sql).toMatch(/ST_AREA\(ST_GEOMFROMTEXT\(\?, 4326\)\)/);
     expect(sql).toMatch(/<= \?/);
     expect(sql).toMatch(/> \?/);
     expect(sql).toContain('OR');
-    expect(params).toEqual([5000, 10000]);
+    expect(params).toEqual([
+      'POINT(39.4972468 -105.0403593)',
+      5000,
+      'POLYGON((0 0,1 0,1 1,0 1,0 0))',
+      10000,
+    ]);
   });
 
   it('supports operator-first 3-tuple conditions in WHERE', () => {
@@ -85,7 +88,7 @@ describe('Explicit SQL expression grammar', () => {
     const qb = new SelectQueryBuilder(config as any, {
       [C6C.SELECT]: [Property_Units.PARCEL_ID],
       [C6C.WHERE]: {
-        0: [[C6C.BETWEEN, Parcel_Sales.SALE_DATE, ['2021-01-01', '2021-12-31']]],
+        0: [[C6C.BETWEEN, Parcel_Sales.SALE_DATE, [[C6C.LIT, '2021-01-01'], [C6C.LIT, '2021-12-31']]]],
       },
     } as any, false);
 
@@ -94,30 +97,25 @@ describe('Explicit SQL expression grammar', () => {
     expect(params.slice(-2)).toEqual(['2021-01-01', '2021-12-31']);
   });
 
-  it('treats safe raw function expressions as SQL expressions', () => {
+  it('supports tuple-based function expressions with literal wrappers', () => {
     const config = buildParcelConfig();
 
     const qb = new SelectQueryBuilder(config as any, {
       [C6C.SELECT]: [Property_Units.PARCEL_ID],
       [C6C.WHERE]: {
-        0: [
-          [
-            "ST_Distance_Sphere(property_units.location, ST_GeomFromText('POINT(39.4972468 -105.0403593)', 4326))",
-            C6C.LESS_THAN_OR_EQUAL_TO,
-            5000,
-          ],
+        [C6C.LESS_THAN_OR_EQUAL_TO]: [
+          [C6C.ST_DISTANCE_SPHERE, Property_Units.LOCATION, [C6C.ST_GEOMFROMTEXT, [C6C.LIT, 'POINT(39.4972468 -105.0403593)'], 4326]],
+          5000,
         ],
       },
     } as any, false);
 
     const { sql, params } = qb.build(Property_Units.TABLE_NAME);
-    expect(sql).toMatch(
-      /ST_Distance_Sphere\(property_units\.location, ST_GeomFromText\('POINT\(39\.4972468 -105\.0403593\)', 4326\)\) <= \?/
-    );
-    expect(params.slice(-1)[0]).toBe(5000);
+    expect(sql).toMatch(/ST_DISTANCE_SPHERE\(property_units\.location, ST_GEOMFROMTEXT\(\?, 4326\)\) <= \?/);
+    expect(params).toEqual(['POINT(39.4972468 -105.0403593)', 5000]);
   });
 
-  it('rejects raw function expressions containing unsafe tokens', () => {
+  it('rejects raw function expression strings', () => {
     const config = buildParcelConfig();
 
     const qb = new SelectQueryBuilder(config as any, {
@@ -133,7 +131,37 @@ describe('Explicit SQL expression grammar', () => {
       },
     } as any, false);
 
-    expect(() => qb.build(Property_Units.TABLE_NAME)).toThrowError(/Potential SQL injection detected/);
+    expect(() => qb.build(Property_Units.TABLE_NAME)).toThrowError(/Bare string/);
+  });
+
+  it('rejects legacy positional AS syntax in function tuples', () => {
+    const config = buildParcelConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      [C6C.SELECT]: [[C6C.COUNT, Property_Units.PARCEL_ID, C6C.AS, 'cnt']],
+    } as any, false);
+
+    expect(() => qb.build(Property_Units.TABLE_NAME)).toThrowError(/Legacy positional AS syntax/);
+  });
+
+  it('rejects legacy positional AS syntax in column tuples', () => {
+    const config = buildParcelConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      [C6C.SELECT]: [[Property_Units.PARCEL_ID, C6C.AS, 'parcel_id_alias']],
+    } as any, false);
+
+    expect(() => qb.build(Property_Units.TABLE_NAME)).toThrowError(/Legacy positional AS syntax/);
+  });
+
+  it('rejects object-rooted function expressions', () => {
+    const config = buildParcelConfig();
+
+    const qb = new SelectQueryBuilder(config as any, {
+      [C6C.SELECT]: [{ [C6C.COUNT]: [Property_Units.PARCEL_ID] }],
+    } as any, false);
+
+    expect(() => qb.build(Property_Units.TABLE_NAME)).toThrowError(/Object-rooted expressions are not supported/);
   });
 
   it('supports explicit AND groupings composed of nested OR clauses', () => {
@@ -146,8 +174,8 @@ describe('Explicit SQL expression grammar', () => {
           { [C6C.GREATER_THAN]: [Property_Units.PARCEL_ID, 100] },
           {
             [C6C.OR]: [
-              { [C6C.BETWEEN]: [Parcel_Sales.SALE_DATE, ['2021-01-01', '2022-06-30']] },
-              { [C6C.BETWEEN]: [Parcel_Sales.SALE_DATE, ['2023-01-01', '2024-06-30']] },
+              { [C6C.BETWEEN]: [Parcel_Sales.SALE_DATE, [[C6C.LIT, '2021-01-01'], [C6C.LIT, '2022-06-30']]] },
+              { [C6C.BETWEEN]: [Parcel_Sales.SALE_DATE, [[C6C.LIT, '2023-01-01'], [C6C.LIT, '2024-06-30']]] },
             ],
           },
         ],

package/src/__tests__/sqlBuilders.test.ts

@@ -4,6 +4,7 @@ import { SelectQueryBuilder } from '../orm/queries/SelectQueryBuilder';
 import { PostQueryBuilder } from '../orm/queries/PostQueryBuilder';
 import { UpdateQueryBuilder } from '../orm/queries/UpdateQueryBuilder';
 import { DeleteQueryBuilder } from '../orm/queries/DeleteQueryBuilder';
+import { alias, call, distinct, fn, lit, order } from '../orm/queryHelpers';
 import { buildTestConfig, buildBinaryTestConfig, buildBinaryTestConfigFqn } from './fixtures/c6.fixture';
 
 describe('SQL Builders', () => {
@@ -11,7 +12,7 @@ describe('SQL Builders', () => {
     const config = buildTestConfig();
     // named params disabled -> positional params array
     const qb = new SelectQueryBuilder(config as any, {
-      SELECT: ['actor.first_name', [C6C.COUNT, 'actor.actor_id', C6C.AS, 'cnt']],
+      SELECT: ['actor.first_name', [C6C.AS, [C6C.COUNT, 'actor.actor_id'], 'cnt']],
       JOIN: {
         [C6C.INNER]: {
           'film_actor fa': {
@@ -20,7 +21,7 @@ describe('SQL Builders', () => {
         }
       },
       WHERE: {
-        'actor.first_name': [C6C.LIKE, '%A%'],
+        'actor.first_name': [C6C.LIKE, [C6C.LIT, '%A%']],
         0: {
           'actor.actor_id': [C6C.GREATER_THAN, 10],
         }
@@ -47,7 +48,7 @@ describe('SQL Builders', () => {
     const config = buildTestConfig();
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
     const qb = new SelectQueryBuilder(config as any, {
-      SELECT: [[C6C.COUNT, 'actor.actor_id', C6C.AS, 'cnt']],
+      SELECT: [[C6C.AS, [C6C.COUNT, 'actor.actor_id'], 'cnt']],
     } as any, false);
 
     qb.build('actor');
@@ -62,6 +63,39 @@ describe('SQL Builders', () => {
     logSpy.mockRestore();
   });
 
+  it('supports custom functions through C6C.CALL and binds string literals', () => {
+    const config = buildTestConfig();
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: [[C6C.AS, [C6C.CALL, 'COALESCE', [C6C.LIT, 'fallback'], 'actor.first_name'], 'resolved_name']],
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+    expect(sql).toContain('COALESCE(?, actor.first_name) AS resolved_name');
+    expect(params).toEqual(['fallback']);
+  });
+
+  it('supports helper builders for fn/call/as/distinct/lit/order', () => {
+    const config = buildTestConfig();
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: [
+        alias(distinct('actor.first_name'), 'distinct_name'),
+        alias(fn(C6C.COUNT, 'actor.actor_id'), 'cnt'),
+        call('COALESCE', lit('N/A'), 'actor.last_name'),
+      ],
+      PAGINATION: {
+        [C6C.ORDER]: [order(fn(C6C.COUNT, 'actor.actor_id'), 'DESC')],
+        [C6C.LIMIT]: 5,
+      },
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+    expect(sql).toContain('DISTINCT actor.first_name AS distinct_name');
+    expect(sql).toContain('COUNT(actor.actor_id) AS cnt');
+    expect(sql).toContain('COALESCE(?, actor.last_name)');
+    expect(sql).toContain('ORDER BY COUNT(actor.actor_id) DESC');
+    expect(params).toEqual(['N/A']);
+  });
+
   it('builds INSERT with ON DUPLICATE KEY UPDATE', () => {
     const config = buildTestConfig();
     const qb = new PostQueryBuilder(config as any, {
@@ -192,6 +226,36 @@ describe('SQL Builders', () => {
     expect(params).toEqual(['ALICE', 5]);
   });
 
+  it('supports expression tuples in UPDATE values', () => {
+    const config = buildTestConfig();
+    const qb = new UpdateQueryBuilder(config as any, {
+      [C6C.UPDATE]: {
+        'actor.first_name': [C6C.CONCAT, [C6C.LIT, 'Mr. '], 'actor.last_name'],
+      },
+      WHERE: {
+        'actor.actor_id': [C6C.EQUAL, 7],
+      },
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+    expect(sql).toContain('`first_name` = CONCAT(?, actor.last_name)');
+    expect(params).toEqual(['Mr. ', 7]);
+  });
+
+  it('supports expression tuples in INSERT values', () => {
+    const config = buildTestConfig();
+    const qb = new PostQueryBuilder(config as any, {
+      [C6C.INSERT]: {
+        'actor.first_name': [C6C.CONCAT, [C6C.LIT, 'HEL'], [C6C.LIT, 'LO']],
+        'actor.last_name': 'SMITH',
+      },
+    } as any, false);
+
+    const { sql, params } = qb.build('actor');
+    expect(sql).toContain('CONCAT(?, ?)');
+    expect(params).toEqual(['HEL', 'LO', 'SMITH']);
+  });
+
   it('builds UPDATE when columns are fully qualified', () => {
     const config = buildTestConfig();
     const qb = new UpdateQueryBuilder(config as any, {
@@ -235,7 +299,7 @@ describe('SQL Builders', () => {
     const config = buildTestConfig();
     const qb = new SelectQueryBuilder(config as any, {
       WHERE: {
-        'actor.binarycol': [C6C.EQUAL, '0123456789abcdef0123456789abcdef']
+        'actor.binarycol': [C6C.EQUAL, [C6C.LIT, '0123456789abcdef0123456789abcdef']]
       }
     } as any, false);
 

package/src/__tests__/sqlExecutorPostUuid.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it, vi } from "vitest";
+import { SqlExecutor } from "../executors/SqlExecutor";
+
+function buildLifecycleHooks() {
+  return { GET: {}, POST: {}, PUT: {}, DELETE: {} } as any;
+}
+
+function buildUuidPrimaryConfig(conn: any) {
+  const restModel: any = {
+    TABLE_NAME: "report_dashboards",
+    PRIMARY: ["report_dashboards.dashboard_id"],
+    PRIMARY_SHORT: ["dashboard_id"],
+    COLUMNS: {
+      "report_dashboards.dashboard_id": "dashboard_id",
+      "report_dashboards.title": "title",
+      "report_dashboards.created_by": "created_by",
+    },
+    TYPE_VALIDATION: {
+      "report_dashboards.dashboard_id": {
+        MYSQL_TYPE: "binary",
+        MAX_LENGTH: "16",
+        AUTO_INCREMENT: false,
+        SKIP_COLUMN_IN_POST: false,
+      },
+      "report_dashboards.title": {
+        MYSQL_TYPE: "varchar",
+        MAX_LENGTH: "120",
+        AUTO_INCREMENT: false,
+        SKIP_COLUMN_IN_POST: false,
+      },
+      "report_dashboards.created_by": {
+        MYSQL_TYPE: "varchar",
+        MAX_LENGTH: "255",
+        AUTO_INCREMENT: false,
+        SKIP_COLUMN_IN_POST: false,
+      },
+    },
+    LIFECYCLE_HOOKS: buildLifecycleHooks(),
+  };
+
+  return {
+    requestMethod: "POST",
+    mysqlPool: {
+      getConnection: vi.fn(async () => conn),
+    },
+    C6: {
+      PREFIX: "",
+      TABLES: {
+        report_dashboards: restModel,
+      },
+    },
+    restModel,
+  } as any;
+}
+
+function buildAutoIncrementConfig(conn: any) {
+  const restModel: any = {
+    TABLE_NAME: "widgets",
+    PRIMARY: ["widgets.widget_id"],
+    PRIMARY_SHORT: ["widget_id"],
+    COLUMNS: {
+      "widgets.widget_id": "widget_id",
+      "widgets.name": "name",
+    },
+    TYPE_VALIDATION: {
+      "widgets.widget_id": {
+        MYSQL_TYPE: "int",
+        MAX_LENGTH: "11",
+        AUTO_INCREMENT: true,
+        SKIP_COLUMN_IN_POST: false,
+      },
+      "widgets.name": {
+        MYSQL_TYPE: "varchar",
+        MAX_LENGTH: "120",
+        AUTO_INCREMENT: false,
+        SKIP_COLUMN_IN_POST: false,
+      },
+    },
+    LIFECYCLE_HOOKS: buildLifecycleHooks(),
+  };
+
+  return {
+    requestMethod: "POST",
+    mysqlPool: {
+      getConnection: vi.fn(async () => conn),
+    },
+    C6: {
+      PREFIX: "",
+      TABLES: {
+        widgets: restModel,
+      },
+    },
+    restModel,
+  } as any;
+}
+
+function buildWriteConn(affectedRows = 1, insertId = 0) {
+  return {
+    beginTransaction: vi.fn(async () => undefined),
+    query: vi.fn(async () => [{ affectedRows, insertId }, []]),
+    commit: vi.fn(async () => undefined),
+    rollback: vi.fn(async () => undefined),
+    release: vi.fn(),
+  };
+}
+
+function expectUuidV7Hex(value: unknown) {
+  expect(typeof value).toBe("string");
+  const hex = String(value).toUpperCase();
+  expect(hex).toMatch(/^[0-9A-F]{32}$/);
+  expect(hex[12]).toBe("7");
+  expect(hex[16]).toMatch(/[89AB]/);
+}
+
+describe("SqlExecutor POST UUID synthesis", () => {
+  it("generates missing UUID primary keys for POST and populates rest payload", async () => {
+    const conn = buildWriteConn(1, 0);
+    const config = buildUuidPrimaryConfig(conn);
+    const request: any = {
+      title: "Board One",
+      created_by: "user-1",
+    };
+
+    const executor = new SqlExecutor<any>(config, request);
+    const result: any = await executor.execute();
+
+    expect(Array.isArray(result.rest)).toBe(true);
+    expect(result.rest).toHaveLength(1);
+    expect(result.rest[0]).toMatchObject({
+      title: "Board One",
+      created_by: "user-1",
+    });
+    expectUuidV7Hex(result.rest[0].dashboard_id);
+
+    const [sql, values] = conn.query.mock.calls[0];
+    expect(sql).toContain("INSERT INTO `report_dashboards`");
+    const uuidBuffers = (values as any[]).filter((value) => Buffer.isBuffer(value));
+    expect(uuidBuffers).toHaveLength(1);
+    expect(uuidBuffers[0]).toHaveLength(16);
+  });
+
+  it("generates UUIDs for each multi-row insert payload row", async () => {
+    const conn = buildWriteConn(2, 0);
+    const config = buildUuidPrimaryConfig(conn);
+    const request: any = {
+      dataInsertMultipleRows: [
+        { title: "One", created_by: "user-1" },
+        { title: "Two", created_by: "user-1" },
+      ],
+    };
+
+    const executor = new SqlExecutor<any>(config, request);
+    const result: any = await executor.execute();
+
+    expect(Array.isArray(result.rest)).toBe(true);
+    expect(result.rest).toHaveLength(2);
+    expectUuidV7Hex(result.rest[0].dashboard_id);
+    expectUuidV7Hex(result.rest[1].dashboard_id);
+    expect(result.rest[0].dashboard_id).not.toBe(result.rest[1].dashboard_id);
+
+    const [, values] = conn.query.mock.calls[0];
+    const uuidBuffers = (values as any[]).filter((value) => Buffer.isBuffer(value));
+    expect(uuidBuffers).toHaveLength(2);
+    expect(uuidBuffers[0]).toHaveLength(16);
+    expect(uuidBuffers[1]).toHaveLength(16);
+  });
+
+  it("fills response rest primary key from insertId for autoincrement inserts", async () => {
+    const conn = buildWriteConn(1, 42);
+    const config = buildAutoIncrementConfig(conn);
+    const request: any = {
+      name: "Auto Row",
+    };
+
+    const executor = new SqlExecutor<any>(config, request);
+    const result: any = await executor.execute();
+
+    expect(Array.isArray(result.rest)).toBe(true);
+    expect(result.rest).toHaveLength(1);
+    expect(result.rest[0]).toMatchObject({
+      widget_id: 42,
+      name: "Auto Row",
+    });
+  });
+});

package/src/constants/C6Constants.ts

@@ -9,6 +9,7 @@ export const C6Constants = {
     BETWEEN: 'BETWEEN',
 
     CONCAT: 'CONCAT',
+    CALL: 'CALL',
     CONVERT_TZ: 'CONVERT_TZ',
     COUNT: 'COUNT',
     COUNT_ALL: 'COUNT_ALL',
@@ -71,6 +72,7 @@ export const C6Constants = {
     LESS_THAN: '<',
     LESS_THAN_OR_EQUAL_TO: '<=',
     LIKE: 'LIKE',
+    LIT: 'LIT',
     LIMIT: 'LIMIT',
     LOCALTIME: 'LOCALTIME',
     LOCALTIMESTAMP: 'LOCALTIMESTAMP',
@@ -198,7 +200,7 @@ export const C6Constants = {
     FINISH: 'FINISH',
     VALIDATE_C6_ENTITY_ID_REGEX: '#^([a-fA-F0-9]{20,35})$#',
 
-};
+} as const;
 
 
 export const C6C = C6Constants;

package/src/executors/HttpExecutor.ts

@@ -14,6 +14,7 @@ import {
 } from "../types/ormInterfaces";
 import {removeInvalidKeys, removePrefixIfExists, TestRestfulResponse} from "../utils/apiHelpers";
 import {checkCache, evictCacheEntry, setCache, userCustomClearCache} from "../utils/cacheManager";
+import type { SqlAllowListStatus } from "../utils/logSql";
 import {sortAndSerializeQueryObject} from "../utils/sortAndSerializeQueryObject";
 import {notifyToast} from "../utils/toastRuntime";
 import {Executor} from "./Executor";
@@ -81,11 +82,18 @@ export class HttpExecutor<
     ) {
         type RT = G['RestTableInterface'];
         type PK = G['PrimaryKey'];
+        const responseRestRaw = (response.data as any)?.rest;
+        const responseRows: Record<string, any>[] = Array.isArray(responseRestRaw)
+            ? responseRestRaw
+            : (responseRestRaw ? [responseRestRaw] : []);
 
         if (this.config.restModel.PRIMARY_SHORT.length === 1) {
             const pk = this.config.restModel.PRIMARY_SHORT[0] as PK;
             try {
-                (request as unknown as Record<PK, RT[PK]>)[pk] = (response.data as any)?.created as RT[PK];
+                const created = (response.data as any)?.created ?? responseRows[0]?.[pk as string];
+                if (created !== undefined) {
+                    (request as unknown as Record<PK, RT[PK]>)[pk] = created as RT[PK];
+                }
             } catch {/* best-effort */}
         } else if (isLocal()) {
             logWithLevel(
@@ -103,13 +111,13 @@ export class HttpExecutor<
                     const normalizedRow = this.stripTableNameFromKeys<RT>(row as Partial<RT>);
                     return removeInvalidKeys<RT>({
                         ...normalizedRow,
-                        ...(index === 0 ? (response?.data as any)?.rest : {}),
+                        ...(responseRows[index] ?? {}),
                     }, this.config.C6.TABLES)
                 })
                 : [
                     removeInvalidKeys<RT>({
                         ...this.stripTableNameFromKeys<RT>(request as unknown as Partial<RT>),
-                        ...(response?.data as any)?.rest,
+                        ...(responseRows[0] ?? {}),
                     }, this.config.C6.TABLES)
                 ],
             stateKey: this.config.restModel.TABLE_NAME,
@@ -201,6 +209,7 @@ export class HttpExecutor<
             const {
                 debug,
                 cacheResults = (C6.GET === requestMethod),
+                skipReactBootstrap = false,
                 dataInsertMultipleRows,
                 success,
                 fetchDependencies = eFetchDependencies.NONE,
@@ -253,10 +262,19 @@ export class HttpExecutor<
                 G['CustomAndRequiredFields'],
                 G['RequestTableOverrides']
             >;
+            const cacheAllowListStatus: SqlAllowListStatus = this.config.sqlAllowListPath
+                ? "allowed"
+                : "not verified";
 
             const evictFromCache =
                 requestMethod === GET && cacheResults
-                    ? () => evictCacheEntry(requestMethod, tableName, cacheRequestData, logContext)
+                    ? () => evictCacheEntry(
+                        requestMethod,
+                        tableName,
+                        cacheRequestData,
+                        logContext,
+                        cacheAllowListStatus,
+                    )
                     : undefined;
 
             // literally impossible for query to be undefined or null here but the editor is too busy licking windows to understand that
@@ -265,7 +283,13 @@ export class HttpExecutor<
             let cachedRequest: Promise<{ data: ResponseDataType }> | false = false;
 
             if (cacheResults) {
-                cachedRequest = checkCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, logContext);
+                cachedRequest = checkCache<ResponseDataType>(
+                    requestMethod,
+                    tableName,
+                    cacheRequestData,
+                    logContext,
+                    cacheAllowListStatus,
+                );
             }
 
             if (cachedRequest) {
@@ -464,6 +488,7 @@ export class HttpExecutor<
                     setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
                         requestArgumentsSerialized: querySerialized,
                         request: axiosActiveRequest,
+                        allowListStatus: cacheAllowListStatus,
                     });
                 }
 
@@ -480,6 +505,7 @@ export class HttpExecutor<
                                 setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
                                     requestArgumentsSerialized: querySerialized,
                                     request: axiosActiveRequest,
+                                    allowListStatus: cacheAllowListStatus,
                                     response,
                                     final: true,
                                 });
@@ -503,6 +529,7 @@ export class HttpExecutor<
                             setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
                                 requestArgumentsSerialized: querySerialized,
                                 request: axiosActiveRequest,
+                                allowListStatus: cacheAllowListStatus,
                                 response,
                             });
                         }
@@ -531,7 +558,7 @@ export class HttpExecutor<
                                 response
                             });
 
-                        if (undefined !== reactBootstrap && response) {
+                        if (undefined !== reactBootstrap && response && !skipReactBootstrap) {
                             switch (requestMethod) {
                                 case GET:
                                     response.data && reactBootstrap.updateRestfulObjectArrays<G['RestTableInterface']>({
@@ -582,6 +609,7 @@ export class HttpExecutor<
                                 setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
                                     requestArgumentsSerialized: querySerialized,
                                     request: axiosActiveRequest,
+                                    allowListStatus: cacheAllowListStatus,
                                     response,
                                     final: !hasNext,
                                 });
@@ -870,6 +898,7 @@ export class HttpExecutor<
                             setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
                                 requestArgumentsSerialized: querySerialized,
                                 request: axiosActiveRequest,
+                                allowListStatus: cacheAllowListStatus,
                                 response,
                                 final: true,
                             });