@carbonorm/carbonnode 6.0.19 → 6.1.0

package/dist/orm/builders/AggregateBuilder.d.ts

@@ -1,7 +1,11 @@
 import { Executor } from "../../executors/Executor";
 import { OrmGenerics } from "../../types/ormGenerics";
+import { iSerializedExpression, tSqlParams } from "./ExpressionSerializer";
 export declare abstract class AggregateBuilder<G extends OrmGenerics> extends Executor<G> {
     protected selectAliases: Set<string>;
     protected assertValidIdentifier(_identifier: string, _context: string): void;
-    buildAggregateField(field: string | any[], params?: any[] | Record<string, any>): string;
+    protected isReferenceExpression(value: string): boolean;
+    protected isKnownFunction(functionName: string): boolean;
+    protected serializeExpression(expression: any, params?: tSqlParams, context?: string, contextColumn?: string): iSerializedExpression;
+    buildAggregateField(field: string | any[], params?: tSqlParams): string;
 }

package/dist/orm/builders/ConditionBuilder.d.ts

@@ -9,6 +9,7 @@ export declare abstract class ConditionBuilder<G extends OrmGenerics> extends Ag
     protected registerAlias(alias: string, table: string): void;
     protected assertValidIdentifier(identifier: string, context: string): void;
     protected isColumnRef(ref: string): boolean;
+    protected isReferenceExpression(value: string): boolean;
     abstract build(table: string): SqlBuilderResult;
     execute(): Promise<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>;
     private readonly BOOLEAN_OPERATORS;
@@ -19,12 +20,10 @@ export declare abstract class ConditionBuilder<G extends OrmGenerics> extends Ag
     private normalizeOperatorKey;
     private formatOperator;
     private isOperator;
-    private looksLikeSafeFunctionExpression;
     private ensureWrapped;
     private joinBooleanParts;
-    private normalizeFunctionField;
-    private buildFunctionCall;
     private serializeOperand;
+    private isExpressionTuple;
     private isPlainArrayLiteral;
     private isPlainObjectLiteral;
     private resolveColumnDefinition;

package/dist/orm/builders/ExpressionSerializer.d.ts

@@ -0,0 +1,22 @@
+export type tSqlParams = any[] | Record<string, any>;
+export interface iSerializedExpression {
+    sql: string;
+    isReference: boolean;
+    isExpression: boolean;
+    isSubSelect: boolean;
+}
+export interface iExpressionSerializerHooks {
+    assertValidIdentifier(identifier: string, context: string): void;
+    isReference(value: string): boolean;
+    addParam?: (params: tSqlParams, column: string, value: any) => string;
+    buildScalarSubSelect?: (subRequest: any, params: tSqlParams) => string;
+    onAlias?: (alias: string) => void;
+    isKnownFunction?: (functionName: string) => boolean;
+}
+export interface iExpressionSerializerOptions {
+    hooks: iExpressionSerializerHooks;
+    params?: tSqlParams;
+    context: string;
+    contextColumn?: string;
+}
+export declare const serializeSqlExpression: (value: any, opts: iExpressionSerializerOptions) => iSerializedExpression;

package/dist/orm/builders/PaginationBuilder.d.ts

@@ -6,12 +6,10 @@ export declare abstract class PaginationBuilder<G extends OrmGenerics> extends J
      *
      * Accepted structures:
      * ```ts
-     * ORDER: {
-     *   // simple column with direction
-     *   [property_units.UNIT_ID]: "DESC",
-     *	 // function call (array of arguments)
-     *   [C6Constants.ST_DISTANCE_SPHERE]: [property_units.LOCATION, F(property_units.LOCATION, "pu_target")]
-     * }
+     * ORDER: [
+     *   [property_units.UNIT_ID, "DESC"],
+     *   [[C6Constants.ST_DISTANCE_SPHERE, property_units.LOCATION, F(property_units.LOCATION, "pu_target")], "ASC"],
+     * ]
      * ```
      */
     buildPaginationClause(pagination: any, params?: any[] | Record<string, any>): string;

package/dist/orm/queryHelpers.d.ts

@@ -1,4 +1,9 @@
-type DerivedTableSpec = Record<string, any> & {};
+import { C6C } from "../constants/C6Constants";
+import { OrderDirection, OrderTerm, SQLExpression, SQLKnownFunction } from "../types/mysqlTypes";
+type DerivedTableSpec = Record<string, any> & {
+    [C6C.SUBSELECT]?: Record<string, any>;
+    [C6C.AS]?: string;
+};
 export declare const isDerivedTableKey: (key: string) => boolean;
 export declare const resolveDerivedTable: (key: string) => DerivedTableSpec | undefined;
 export declare const derivedTable: <T extends DerivedTableSpec>(spec: T) => T;
@@ -8,4 +13,10 @@ export declare const fieldEq: (leftCol: string, rightCol: string, leftAlias: str
 export declare const distSphere: (fromCol: string, toCol: string, fromAlias: string, toAlias: string) => any[];
 export declare const bbox: (minLng: number, minLat: number, maxLng: number, maxLat: number) => any[];
 export declare const stContains: (envelope: string, shape: string) => any[];
+export declare const fn: <Fn extends SQLKnownFunction>(functionName: Fn, ...args: SQLExpression[]) => [Fn, ...SQLExpression[]];
+export declare const call: (functionName: string, ...args: SQLExpression[]) => [typeof C6C.CALL, string, ...SQLExpression[]];
+export declare const alias: (expression: SQLExpression, aliasName: string) => [typeof C6C.AS, SQLExpression, string];
+export declare const distinct: (expression: SQLExpression) => [typeof C6C.DISTINCT, SQLExpression];
+export declare const lit: (value: any) => [typeof C6C.LIT, any];
+export declare const order: (expression: SQLExpression, direction?: OrderDirection) => OrderTerm;
 export {};

package/dist/types/mysqlTypes.d.ts

@@ -1,4 +1,9 @@
-export type SQLFunction = 'COUNT' | 'GROUP_CONCAT' | 'MAX' | 'MIN' | 'SUM' | 'DISTINCT';
+export declare const SQL_KNOWN_FUNCTIONS: readonly ["ADDDATE", "ADDTIME", "CONCAT", "CONVERT_TZ", "COUNT", "COUNT_ALL", "CURRENT_DATE", "CURRENT_TIMESTAMP", "DAY", "DAY_HOUR", "DAY_MICROSECOND", "DAY_MINUTE", "DAY_SECOND", "DAYNAME", "DAYOFMONTH", "DAYOFWEEK", "DAYOFYEAR", "DATE", "DATE_ADD", "DATEDIFF", "DATE_SUB", "DATE_FORMAT", "EXTRACT", "FROM_DAYS", "FROM_UNIXTIME", "GET_FORMAT", "GROUP_CONCAT", "HEX", "HOUR", "HOUR_MICROSECOND", "HOUR_MINUTE", "HOUR_SECOND", "INTERVAL", "LOCALTIME", "LOCALTIMESTAMP", "MAKEDATE", "MAKETIME", "MAX", "MBRContains", "MICROSECOND", "MIN", "MINUTE", "MINUTE_MICROSECOND", "MINUTE_SECOND", "MONTH", "MONTHNAME", "NOW", "POINT", "POLYGON", "SECOND", "SECOND_MICROSECOND", "ST_Area", "ST_AsBinary", "ST_AsText", "ST_Buffer", "ST_Contains", "ST_Crosses", "ST_Difference", "ST_Dimension", "ST_Disjoint", "ST_Distance", "ST_Distance_Sphere", "ST_EndPoint", "ST_Envelope", "ST_Equals", "ST_GeomFromGeoJSON", "ST_GeomFromText", "ST_GeomFromWKB", "ST_Intersects", "ST_Length", "ST_MakeEnvelope", "ST_Overlaps", "ST_Point", "ST_SetSRID", "ST_SRID", "ST_StartPoint", "ST_SymDifference", "ST_Touches", "ST_Union", "ST_Within", "ST_X", "ST_Y", "STR_TO_DATE", "SUBDATE", "SUBTIME", "SUM", "SYSDATE", "TIME", "TIME_FORMAT", "TIME_TO_SEC", "TIMEDIFF", "TIMESTAMP", "TIMESTAMPADD", "TIMESTAMPDIFF", "TO_DAYS", "TO_SECONDS", "TRANSACTION_TIMESTAMP", "UNHEX", "UNIX_TIMESTAMP", "UTC_DATE", "UTC_TIME", "UTC_TIMESTAMP", "WEEKDAY", "WEEKOFYEAR", "YEARWEEK"];
+export type SQLKnownFunction = typeof SQL_KNOWN_FUNCTIONS[number];
+export type SQLFunction = SQLKnownFunction;
 export type SQLComparisonOperator = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'IN' | 'NOT IN' | 'LIKE' | 'IS NULL' | 'IS NOT NULL' | 'BETWEEN' | 'LESS_THAN' | 'GREATER_THAN';
 export type JoinType = 'INNER' | 'LEFT_OUTER' | 'RIGHT_OUTER';
 export type OrderDirection = 'ASC' | 'DESC';
+export type SQLExpression = string | number | boolean | null | SQLExpressionTuple;
+export type SQLExpressionTuple = ['AS', SQLExpression, string] | ['DISTINCT', SQLExpression] | ['CALL', string, ...SQLExpression[]] | ['LIT', any] | ['PARAM', any] | ['SUBSELECT', Record<string, any>] | [SQLKnownFunction, ...SQLExpression[]];
+export type OrderTerm = [SQLExpression, OrderDirection?];

package/dist/types/ormInterfaces.d.ts

@@ -2,7 +2,7 @@ import type { AxiosInstance, AxiosResponse } from "axios";
 import type { Pool } from "mysql2/promise";
 import { eFetchDependencies } from "./dynamicFetching";
 import { Modify } from "./modifyTypes";
-import { JoinType, OrderDirection, SQLComparisonOperator, SQLFunction } from "./mysqlTypes";
+import { JoinType, OrderTerm, SQLComparisonOperator, SQLExpression } from "./mysqlTypes";
 import type { CarbonReact, iStateAdapter } from "@carbonorm/carbonreact";
 import type { OrmGenerics } from "./ormGenerics";
 import { restOrm } from "../api/restOrm";
@@ -41,7 +41,7 @@ export type SubSelect<T extends {
 };
 export type SelectField<T extends {
     [key: string]: any;
-} = any> = keyof T | [keyof T, 'AS', string] | [SQLFunction, keyof T] | [SQLFunction, keyof T, string] | SubSelect<T>;
+} = any> = keyof T | SQLExpression | SubSelect<T>;
 export type WhereClause<T = any> = Partial<T> | LogicalGroup<T> | ComparisonClause<T>;
 export type LogicalGroup<T = any> = {
     [logicalGroup: string]: Array<WhereClause<T>>;
@@ -54,10 +54,10 @@ export type JoinClause<T = any> = {
 export type Join<T = any> = {
     [K in JoinType]?: JoinClause<T>;
 };
-export type Pagination<T = any> = {
+export type Pagination = {
     PAGE?: number;
     LIMIT?: number | null;
-    ORDER?: Partial<Record<keyof T, OrderDirection>>;
+    ORDER?: OrderTerm[];
 };
 export type RequestGetPutDeleteBody<T extends {
     [key: string]: any;
@@ -67,7 +67,7 @@ export type RequestGetPutDeleteBody<T extends {
     DELETE?: boolean;
     WHERE?: WhereClause<T>;
     JOIN?: Join<T>;
-    PAGINATION?: Pagination<T>;
+    PAGINATION?: Pagination;
 };
 export type RequestPostBody<T extends {
     [key: string]: any;
@@ -80,6 +80,7 @@ export type iAPI<T extends {
 }> = T & {
     dataInsertMultipleRows?: T[];
     cacheResults?: boolean;
+    skipReactBootstrap?: boolean;
     fetchDependencies?: number | eFetchDependencies | Awaited<iGetC6RestResponse<any>>[];
     debug?: boolean;
     success?: string | ((r: AxiosResponse) => string | void);
@@ -105,6 +106,7 @@ export interface iCacheResponse<ResponseDataType = any> {
 export interface iCacheAPI<ResponseDataType = any> {
     requestArgumentsSerialized: string;
     request: Promise<iCacheResponse<ResponseDataType>>;
+    allowListStatus?: "allowed" | "denied" | "not verified";
     response?: iCacheResponse<ResponseDataType> & {
         __carbonTiming?: {
             start: number;

package/dist/utils/cacheManager.d.ts

@@ -1,10 +1,11 @@
 import type { iCacheAPI, iCacheResponse } from "../types/ormInterfaces";
 import { LogContext } from "./logLevel";
+import { SqlAllowListStatus } from "./logSql";
 export declare const apiRequestCache: Map<string, iCacheAPI<any>>;
 export declare const userCustomClearCache: (() => void)[];
 export declare function clearCache(props?: {
     ignoreWarning?: boolean;
 }): void;
-export declare function checkCache<ResponseDataType = any>(method: string, tableName: string | string[], requestData: any, logContext: LogContext): Promise<iCacheResponse<ResponseDataType>> | false;
+export declare function checkCache<ResponseDataType = any>(method: string, tableName: string | string[], requestData: any, logContext?: LogContext, allowListStatus?: SqlAllowListStatus): Promise<iCacheResponse<ResponseDataType>> | false;
 export declare function setCache<ResponseDataType = any>(method: string, tableName: string | string[], requestData: any, cacheEntry: iCacheAPI<ResponseDataType>): void;
-export declare function evictCacheEntry(method: string, tableName: string | string[], requestData: any, logContext?: LogContext): boolean;
+export declare function evictCacheEntry(method: string, tableName: string | string[], requestData: any, logContext?: LogContext, allowListStatus?: SqlAllowListStatus): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonorm/carbonnode",
-  "version": "6.0.19",
+  "version": "6.1.0",
   "browser": "dist/index.umd.js",
   "repository": {
     "type": "git",
@@ -20,7 +20,7 @@
     "hooksPath": ".githooks"
   },
   "dependencies": {
-    "@carbonorm/carbonreact": "^6.0.3",
+    "@carbonorm/carbonreact": "^6.0.4",
     "buffer": "^6.0.3",
     "geojson": "^0.5.0",
     "handlebars": "^4.7.8",

package/scripts/assets/handlebars/C6.test.ts.handlebars

@@ -101,7 +101,7 @@ function buildScalarValue(meta: any, columnName: string, seedRow: any) {
         'geometrycollection',
     ];
     if (geometryTypes.some((type) => mysqlType.includes(type))) {
-        return "ST_GeomFromText('POINT(0 0)')";
+        return [C6.ST_GEOMFROMTEXT, [C6.LIT, 'POINT(0 0)']];
     }
 
     if (mysqlType === 'json') return {};
@@ -236,7 +236,7 @@ function buildUpdatedValue(meta: any, columnName: string, currentValue: any) {
 
     if (mysqlType === 'year') return new Date().getFullYear();
     if (geometryTypes.some((type) => mysqlType.includes(type))) {
-        return "ST_GeomFromText('POINT(1 1)')";
+        return [C6.ST_GEOMFROMTEXT, [C6.LIT, 'POINT(1 1)']];
     }
     if (mysqlType === 'json') return { updated: true };
 
@@ -525,7 +525,7 @@ describe('sakila-db generated C6 bindings', () => {
                     restBinding.Get({
                         [C6.PAGINATION]: {
                             [C6.LIMIT]: 1,
-                            [C6.ORDER]: { [primaryFull]: 'DESC' },
+                            [C6.ORDER]: [[primaryFull, C6.DESC]],
                         },
                         cacheResults: false,
                     } as any)
@@ -550,7 +550,7 @@ describe('sakila-db generated C6 bindings', () => {
                         restBinding.Get({
                             [C6.PAGINATION]: {
                                 [C6.LIMIT]: 1,
-                                [C6.ORDER]: { [primaryFull]: 'DESC' },
+                                [C6.ORDER]: [[primaryFull, C6.DESC]],
                             },
                             cacheResults: false,
                         } as any)

package/src/__tests__/cacheManager.test.ts

@@ -79,14 +79,42 @@ describe("cacheManager with map storage", () => {
           },
         },
       } as any,
+      allowListStatus: "allowed",
       final: true,
     });
 
     expect(evictCacheEntry("GET", "table", requestData, { verbose: true })).toBe(true);
     expect(logSpy).toHaveBeenCalledTimes(1);
     expect(String(logSpy.mock.calls[0]?.[0] ?? "")).toContain("[CACHE EVICTED]");
+    expect(String(logSpy.mock.calls[0]?.[0] ?? "")).toContain("[VERIFIED]");
     expect(String(logSpy.mock.calls[0]?.[0] ?? "")).toContain("[SELECT]");
 
     logSpy.mockRestore();
   });
+
+  it("logs verified for cache hits when allowlist is provided", () => {
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    const mockRequest = Promise.resolve({ data: { rest: [] } }) as AxiosPromise;
+
+    setCache("GET", "table", requestData, {
+      requestArgumentsSerialized: "serialized",
+      request: mockRequest,
+      response: {
+        data: {
+          sql: {
+            sql: "SELECT * FROM table WHERE id = 1",
+          },
+        },
+      } as any,
+      final: true,
+    });
+
+    const cached = checkCache("GET", "table", requestData, { verbose: true }, "allowed");
+    expect(cached).toBe(mockRequest);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    expect(String(logSpy.mock.calls[0]?.[0] ?? "")).toContain("[CACHE HIT]");
+    expect(String(logSpy.mock.calls[0]?.[0] ?? "")).toContain("[VERIFIED]");
+
+    logSpy.mockRestore();
+  });
 });

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

@@ -3,7 +3,7 @@ import axios from "axios";
 import { AddressInfo } from "net";
 import {describe, it, expect, beforeAll, afterAll} from "vitest";
 import { restOrm } from "@carbonorm/carbonnode";
-import {Actor, C6, Film_Actor} from "./sakila-db/C6.js";
+import {Actor, C6, Film_Actor, TABLES} from "./sakila-db/C6";
 import {C6C} from "../constants/C6Constants";
 import createTestServer from "./fixtures/createTestServer";
 
@@ -13,14 +13,14 @@ let restURL: string;
 let axiosClient: ReturnType<typeof axios.create>;
 const actorHttp = restOrm<any>(() => ({
     C6,
-    restModel: C6.TABLES.actor,
+    restModel: TABLES.actor,
     restURL,
     axios: axiosClient,
     verbose: false,
 }));
 const filmActorHttp = restOrm<any>(() => ({
     C6,
-    restModel: C6.TABLES.film_actor,
+    restModel: TABLES.film_actor,
     restURL,
     axios: axiosClient,
     verbose: false,
@@ -100,30 +100,33 @@ describe("ExpressHandler e2e", () => {
         } as any);
 
         let data = await actorRequest("GET", {
-            [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+            [C6C.WHERE]: {
+                [Actor.FIRST_NAME]: [C6C.EQUAL, [C6C.LIT, first_name]],
+                [Actor.LAST_NAME]: [C6C.EQUAL, [C6C.LIT, last_name]],
+            },
             [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
         } as any);
 
         expect(data?.rest).toHaveLength(1);
-        const testId = data?.rest[0].actor_id;
+        const testId = Number(data?.rest[0].actor_id);
 
         await actorRequest("PUT", {
-            [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: [C6C.EQUAL, [C6C.LIT, Number(testId)]] },
             [C6C.UPDATE]: { first_name: "Updated" },
         } as any);
 
         data = await actorRequest("GET", {
-            [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: [C6C.EQUAL, [C6C.LIT, Number(testId)]] },
         } as any);
         expect(data?.rest).toHaveLength(1);
         expect(data?.rest[0].first_name).toBe("Updated");
 
         await actorRequest("DELETE", {
-            [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: [C6C.EQUAL, [C6C.LIT, Number(testId)]] },
             [C6C.DELETE]: true,
         } as any);
         data = await actorRequest("GET", {
-            [C6C.WHERE]: { [Actor.ACTOR_ID]: testId },
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: [C6C.EQUAL, [C6C.LIT, Number(testId)]] },
             cacheResults: false,
         } as any);
         expect(Array.isArray(data?.rest)).toBe(true);
@@ -142,20 +145,23 @@ describe("ExpressHandler e2e", () => {
         const payload = { greeting: "hello", flags: [1, true] };
 
         let data = await actorRequest("GET", {
-            [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+            [C6C.WHERE]: {
+                [Actor.FIRST_NAME]: [C6C.EQUAL, [C6C.LIT, first_name]],
+                [Actor.LAST_NAME]: [C6C.EQUAL, [C6C.LIT, last_name]],
+            },
             [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
         } as any);
 
-        const actorId = data?.rest?.[0]?.actor_id;
+        const actorId = Number(data?.rest?.[0]?.actor_id);
         expect(actorId).toBeTruthy();
 
         await actorRequest("PUT", {
-            [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: [C6C.EQUAL, [C6C.LIT, Number(actorId)]] },
             [C6C.UPDATE]: { first_name: payload },
         } as any);
 
         data = await actorRequest("GET", {
-            [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+            [C6C.WHERE]: { [Actor.ACTOR_ID]: [C6C.EQUAL, [C6C.LIT, Number(actorId)]] },
         } as any);
 
         expect(data?.rest?.[0]?.first_name).toBe(JSON.stringify(payload));
@@ -171,11 +177,14 @@ describe("ExpressHandler e2e", () => {
         } as any);
 
         const data = await actorRequest("GET", {
-            [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+            [C6C.WHERE]: {
+                [Actor.FIRST_NAME]: [C6C.EQUAL, [C6C.LIT, first_name]],
+                [Actor.LAST_NAME]: [C6C.EQUAL, [C6C.LIT, last_name]],
+            },
             [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
         } as any);
 
-        const actorId = data?.rest?.[0]?.actor_id;
+        const actorId = Number(data?.rest?.[0]?.actor_id);
         expect(actorId).toBeTruthy();
 
         const operatorLike = { [C6C.GREATER_THAN]: "oops" } as any;
@@ -183,12 +192,12 @@ describe("ExpressHandler e2e", () => {
         try {
             const actorSql = restOrm<any>(() => ({
                 C6,
-                restModel: C6.TABLES.actor,
+                restModel: TABLES.actor,
                 mysqlPool: pool,
                 verbose: false,
             }));
             await actorSql.Put({
-                [C6C.WHERE]: { [Actor.ACTOR_ID]: actorId },
+                [C6C.WHERE]: { [Actor.ACTOR_ID]: [C6C.EQUAL, [C6C.LIT, Number(actorId)]] },
                 [C6C.UPDATE]: { first_name: operatorLike },
             } as any);
             throw new Error('Expected PUT to reject for operator-like payload.');

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

@@ -2,8 +2,8 @@ import mysql from "mysql2/promise";
 import axios from "axios";
 import { AddressInfo } from "net";
 import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import { restOrm } from "@carbonorm/carbonnode";
-import { Actor, C6 } from "./sakila-db/C6.js";
+import {iGetC6RestResponse, restOrm } from "@carbonorm/carbonnode";
+import {Actor, C6, iActor, TABLES} from "./sakila-db/C6";
 import { C6C } from "../constants/C6Constants";
 import createTestServer from "./fixtures/createTestServer";
 
@@ -13,7 +13,7 @@ let restURL: string;
 let axiosClient: ReturnType<typeof axios.create>;
 const actorHttp = restOrm<any>(() => ({
   C6,
-  restModel: C6.TABLES.actor,
+  restModel: TABLES.actor,
   restURL,
   axios: axiosClient,
   verbose: false,
@@ -76,23 +76,26 @@ describe("HttpExecutor singular e2e", () => {
       step = "GET-complex";
       // Fetch inserted id using complex query
       let data = await actorRequest("GET", {
-        [C6C.WHERE]: { [Actor.FIRST_NAME]: first_name, [Actor.LAST_NAME]: last_name },
+        [C6C.WHERE]: {
+          [Actor.FIRST_NAME]: [C6C.EQUAL, [C6C.LIT, first_name]],
+          [Actor.LAST_NAME]: [C6C.EQUAL, [C6C.LIT, last_name]],
+        },
         [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
       });
 
       expect(data.rest).toHaveLength(1);
-      const testId = data.rest[0].actor_id;
+      const testId = Number(data.rest[0].actor_id);
 
       step = "GET-singular";
       // GET singular
-      data = await actorRequest("GET", { actor_id: testId } as any);
+      data = await actorRequest("GET", { actor_id: Number(testId) } as any);
       expect(data.rest).toHaveLength(1);
       expect(data.rest[0].actor_id).toBe(testId);
 
       step = "PUT-singular";
       // PUT singular
-      await actorRequest("PUT", { actor_id: testId, first_name: "Updated" } as any);
-      data = await actorRequest("GET", { actor_id: testId, cacheResults: false } as any);
+      await actorRequest("PUT", { actor_id: Number(testId), first_name: "Updated" } as any);
+      data = await actorRequest("GET", { actor_id: Number(testId), cacheResults: false } as any);
       expect(data.rest).toHaveLength(1);
       expect(data.rest[0].first_name).toBe("Updated");
 
@@ -105,7 +108,7 @@ describe("HttpExecutor singular e2e", () => {
       } as any;
       const actorHttpWithReact = restOrm<any>(() => ({
         C6,
-        restModel: C6.TABLES.actor,
+        restModel: TABLES.actor,
         restURL,
         axios: axiosClient,
         verbose: false,
@@ -123,8 +126,8 @@ describe("HttpExecutor singular e2e", () => {
 
       step = "DELETE-singular";
       // DELETE singular
-      await actorRequest("DELETE", { actor_id: testId } as any);
-      data = await actorRequest("GET", { actor_id: testId, cacheResults: false } as any);
+      await actorRequest("DELETE", { actor_id: Number(testId) } as any);
+      data = await actorRequest("GET", { actor_id: Number(testId), cacheResults: false } as any);
       expect(Array.isArray(data.rest)).toBe(true);
       expect(data.rest.length).toBe(0);
     } catch (error: any) {
@@ -133,9 +136,9 @@ describe("HttpExecutor singular e2e", () => {
   });
 
   it("exposes next when pagination continues", async () => {
-    const data = await actorRequest("GET", {
+    const data: iGetC6RestResponse<iActor, {}> = await actorRequest("GET", {
       [C6C.PAGINATION]: { [C6C.LIMIT]: 2 },
-    } as any);
+    });
 
     expect(Array.isArray(data.rest)).toBe(true);
     expect(data.rest).toHaveLength(2);
@@ -148,7 +151,7 @@ describe("HttpExecutor singular e2e", () => {
   });
 
   it("exposes limit 1 does not expose next", async () => {
-    const data = await actorRequest("GET", {
+    const data: iGetC6RestResponse<iActor, {}>  = await actorRequest("GET", {
       [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
     } as any);
 
@@ -157,4 +160,40 @@ describe("HttpExecutor singular e2e", () => {
     expect(typeof data.next).toBe("undefined");
 
   });
+
+  it("skips reactBootstrap state sync when skipReactBootstrap is true", async () => {
+    const updateStub = vi.fn();
+    const reactBootstrap = {
+      updateRestfulObjectArrays: updateStub,
+      deleteRestfulObjectArrays: vi.fn(),
+    } as any;
+
+    const actorHttpWithReact = restOrm<any>(() => ({
+      C6,
+      restModel: TABLES.actor,
+      restURL,
+      axios: axiosClient,
+      verbose: false,
+      reactBootstrap,
+    }));
+
+    const skipped = await actorHttpWithReact.Get({
+      [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+      skipReactBootstrap: true,
+      cacheResults: false,
+    } as any);
+
+    expect(Array.isArray(skipped.rest)).toBe(true);
+    expect(skipped.rest).toHaveLength(1);
+    expect(updateStub).not.toHaveBeenCalled();
+
+    const normal = await actorHttpWithReact.Get({
+      [C6C.PAGINATION]: { [C6C.LIMIT]: 1 },
+      cacheResults: false,
+    } as any);
+
+    expect(Array.isArray(normal.rest)).toBe(true);
+    expect(normal.rest).toHaveLength(1);
+    expect(updateStub).toHaveBeenCalledTimes(1);
+  });
 });

package/src/__tests__/normalizeSingularRequest.test.ts

@@ -33,13 +33,15 @@ function makeModel(table: string, pkShorts: string[], extraCols: string[] = []):
   } as any;
 }
 
+const litEq = (value: any) => [C6C.EQUAL, [C6C.LIT, value]];
+
 describe('normalizeSingularRequest', () => {
   it('converts GET singular T into WHERE by PK', () => {
     const model = makeModel('actor', ['actor_id'], ['first_name']);
     const req = { actor_id: 5 } as any;
     const out = normalizeSingularRequest('GET', req, model);
     expect(out).toHaveProperty(C6C.WHERE);
-    expect((out as any)[C6C.WHERE]).toEqual({ 'actor.actor_id': 5 });
+    expect((out as any)[C6C.WHERE]).toEqual({ 'actor.actor_id': litEq(5) });
   });
 
   it('converts DELETE singular T into DELETE:true and WHERE by PK', () => {
@@ -47,14 +49,14 @@ describe('normalizeSingularRequest', () => {
     const req = { actor_id: 7 } as any;
     const out = normalizeSingularRequest('DELETE', req, model);
     expect((out as any)[C6C.DELETE]).toBe(true);
-    expect((out as any)[C6C.WHERE]).toEqual({ 'actor.actor_id': 7 });
+    expect((out as any)[C6C.WHERE]).toEqual({ 'actor.actor_id': litEq(7) });
   });
 
   it('converts PUT singular T into UPDATE (non-PK fields) and WHERE by PK', () => {
     const model = makeModel('actor', ['actor_id'], ['first_name']);
     const req = { actor_id: 9, first_name: 'NEW' } as any;
     const out = normalizeSingularRequest('PUT', req, model);
-    expect((out as any)[C6C.WHERE]).toEqual({ 'actor.actor_id': 9 });
+    expect((out as any)[C6C.WHERE]).toEqual({ 'actor.actor_id': litEq(9) });
     expect((out as any)[C6C.UPDATE]).toEqual({ first_name: 'NEW' });
   });
 
@@ -76,7 +78,7 @@ describe('normalizeSingularRequest', () => {
     const model = makeModel('link', ['from_id', 'to_id']);
     const ok = { from_id: 1, to_id: 2 } as any;
     const out = normalizeSingularRequest('GET', ok, model);
-    expect((out as any)[C6C.WHERE]).toEqual({ 'link.from_id': 1, 'link.to_id': 2 });
+    expect((out as any)[C6C.WHERE]).toEqual({ 'link.from_id': litEq(1), 'link.to_id': litEq(2) });
 
     const missing = { from_id: 1 } as any;
     expect(() => normalizeSingularRequest('DELETE', missing, model)).toThrow(/Missing: \[to_id\]/);
@@ -102,11 +104,27 @@ describe('normalizeSingularRequest', () => {
     const out = normalizeSingularRequest('GET', req, model);
     expect(out).toBe(req);
   });
+
+  it('preserves skipReactBootstrap metadata across normalization', () => {
+    const model = makeModel('actor', ['actor_id'], ['first_name']);
+    const req = {
+      actor_id: 1,
+      first_name: 'S',
+      cacheResults: false,
+      skipReactBootstrap: true,
+    } as any;
+
+    const out = normalizeSingularRequest('PUT', req, model) as any;
+    expect(out.skipReactBootstrap).toBe(true);
+    expect(out.cacheResults).toBe(false);
+    expect(out[C6C.UPDATE]).toEqual({ first_name: 'S' });
+  });
+
   it('accepts fully-qualified PK and maps WHERE/UPDATE to short keys', () => {
     const model = makeModel('actor', ['actor_id'], ['first_name']);
     const req = { 'actor.actor_id': 12, 'actor.first_name': 'FN' } as any;
     const out = normalizeSingularRequest('PUT', req, model) as any;
-    expect(out[C6C.WHERE]).toEqual({ 'actor.actor_id': 12 });
+    expect(out[C6C.WHERE]).toEqual({ 'actor.actor_id': litEq(12) });
     expect(out[C6C.UPDATE]).toEqual({ first_name: 'FN' });
   });
 
@@ -114,7 +132,7 @@ describe('normalizeSingularRequest', () => {
     const model = makeModel('actor', ['actor_id'], ['first_name']);
     const req = { 'actor.actor_id': 44, first_name: 'Mix' } as any;
     const out = normalizeSingularRequest('PUT', req, model) as any;
-    expect(out[C6C.WHERE]).toEqual({ 'actor.actor_id': 44 });
+    expect(out[C6C.WHERE]).toEqual({ 'actor.actor_id': litEq(44) });
     expect(out[C6C.UPDATE]).toEqual({ first_name: 'Mix' });
   });
 
@@ -123,13 +141,13 @@ describe('normalizeSingularRequest', () => {
     const req = { 'actor.actor_id': 77 } as any;
     const out = normalizeSingularRequest('DELETE', req, model) as any;
     expect(out[C6C.DELETE]).toBe(true);
-    expect(out[C6C.WHERE]).toEqual({ 'actor.actor_id': 77 });
+    expect(out[C6C.WHERE]).toEqual({ 'actor.actor_id': litEq(77) });
   });
 
   it('supports composite PKs with fully-qualified keys', () => {
     const model = makeModel('link', ['from_id', 'to_id']);
     const req = { 'link.from_id': 1, 'link.to_id': 2, 'link.label': 'L' } as any;
     const out = normalizeSingularRequest('PUT', req, model) as any;
-    expect(out[C6C.WHERE]).toEqual({ 'link.from_id': 1, 'link.to_id': 2 });
+    expect(out[C6C.WHERE]).toEqual({ 'link.from_id': litEq(1), 'link.to_id': litEq(2) });
   });
 });

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

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