@carbonorm/carbonnode 6.0.17 → 6.0.19

package/src/__tests__/sakila-db/sqlResponses/C6.rental.put.lookup.json

@@ -2,12 +2,12 @@
   "rest": [
     {
       "rental_id": 16050,
-      "rental_date": "2026-02-12T19:14:08.000Z",
+      "rental_date": "2026-02-13T01:19:18.000Z",
       "inventory_id": 1,
       "customer_id": 1,
-      "return_date": "2026-02-12T19:14:08.000Z",
+      "return_date": "2026-02-13T01:19:18.000Z",
       "staff_id": 1,
-      "last_update": "2026-02-12T19:14:08.000Z"
+      "last_update": "2026-02-13T01:19:18.000Z"
     }
   ],
   "sql": {

package/src/__tests__/sqlExecutor.cacheEviction.test.ts

@@ -0,0 +1,79 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { restOrm } from "../api/restOrm";
+import { apiRequestCache, clearCache } from "../utils/cacheManager";
+import { buildTestConfig } from "./fixtures/c6.fixture";
+
+describe("SqlExecutor cache eviction", () => {
+  const rows = [
+    {
+      actor_id: 1,
+      first_name: "ALICE",
+      last_name: "ONE",
+    },
+  ];
+
+  const buildOrm = () => {
+    const conn: any = {
+      beginTransaction: vi.fn(async () => undefined),
+      query: vi.fn(async () => [rows, []]),
+      commit: vi.fn(async () => undefined),
+      rollback: vi.fn(async () => undefined),
+      release: vi.fn(),
+    };
+
+    const baseConfig = buildTestConfig() as any;
+
+    const actorSql = restOrm<any>(() => ({
+      ...baseConfig,
+      mysqlPool: {
+        getConnection: vi.fn(async () => conn),
+      },
+      verbose: false,
+    }));
+
+    return {
+      actorSql,
+      conn,
+    };
+  };
+
+  beforeEach(() => {
+    clearCache({ ignoreWarning: true });
+  });
+
+  it("adds evictFromCache for cached GET responses", async () => {
+    const { actorSql, conn } = buildOrm();
+
+    const response = await actorSql.Get({ actor_id: 1, cacheResults: true } as any);
+
+    expect(conn.query).toHaveBeenCalledTimes(1);
+    expect(typeof response.evictFromCache).toBe("function");
+    expect(apiRequestCache.size).toBe(1);
+
+    expect(response.evictFromCache?.()).toBe(true);
+    expect(apiRequestCache.size).toBe(0);
+    expect(response.evictFromCache?.()).toBe(false);
+  });
+
+  it("does not add evictFromCache when cacheResults is false", async () => {
+    const { actorSql, conn } = buildOrm();
+
+    const response = await actorSql.Get({ actor_id: 1, cacheResults: false } as any);
+
+    expect(conn.query).toHaveBeenCalledTimes(1);
+    expect(response.evictFromCache).toBeUndefined();
+    expect(apiRequestCache.size).toBe(0);
+  });
+
+  it("keeps evictFromCache on cache hits", async () => {
+    const { actorSql, conn } = buildOrm();
+
+    await actorSql.Get({ actor_id: 1, cacheResults: true } as any);
+    const cached = await actorSql.Get({ actor_id: 1, cacheResults: true } as any);
+
+    expect(conn.query).toHaveBeenCalledTimes(1);
+    expect(typeof cached.evictFromCache).toBe("function");
+    expect(cached.evictFromCache?.()).toBe(true);
+    expect(apiRequestCache.size).toBe(0);
+  });
+});

package/src/executors/HttpExecutor.ts

@@ -13,7 +13,7 @@ import {
     PUT, RequestQueryBody
 } from "../types/ormInterfaces";
 import {removeInvalidKeys, removePrefixIfExists, TestRestfulResponse} from "../utils/apiHelpers";
-import {checkCache, setCache, userCustomClearCache} from "../utils/cacheManager";
+import {checkCache, evictCacheEntry, setCache, userCustomClearCache} from "../utils/cacheManager";
 import {sortAndSerializeQueryObject} from "../utils/sortAndSerializeQueryObject";
 import {notifyToast} from "../utils/toastRuntime";
 import {Executor} from "./Executor";
@@ -254,6 +254,11 @@ export class HttpExecutor<
                 G['RequestTableOverrides']
             >;
 
+            const evictFromCache =
+                requestMethod === GET && cacheResults
+                    ? () => evictCacheEntry(requestMethod, tableName, cacheRequestData, logContext)
+                    : undefined;
+
             // 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 ?? {});
 
@@ -264,7 +269,14 @@ export class HttpExecutor<
             }
 
             if (cachedRequest) {
-                return (await cachedRequest).data;
+                const cachedData = (await cachedRequest).data;
+                if (evictFromCache
+                    && cachedData
+                    && typeof cachedData === "object"
+                    && Array.isArray((cachedData as C6RestResponse<'GET', G['RestTableInterface']>).rest)) {
+                    (cachedData as C6RestResponse<'GET', G['RestTableInterface']>).evictFromCache = evictFromCache;
+                }
+                return cachedData;
             }
 
             if (cacheResults) {
@@ -544,7 +556,7 @@ export class HttpExecutor<
                             callback();
                         }
 
-                        if (C6.GET === requestMethod && this.isRestResponse(response)) {
+                        if (requestMethod === GET && this.isRestResponse(response)) {
 
                             const responseData =
                                 response.data as DetermineResponseDataType<'GET', G['RestTableInterface']>;
@@ -562,6 +574,10 @@ export class HttpExecutor<
                                 responseData.next = undefined;    // short page => done
                             }
 
+                            if (cachingConfirmed && evictFromCache) {
+                                responseData.evictFromCache = evictFromCache;
+                            }
+
                             if (cachingConfirmed) {
                                 setCache<ResponseDataType>(requestMethod, tableName, cacheRequestData, {
                                     requestArgumentsSerialized: querySerialized,

package/src/executors/SqlExecutor.ts

@@ -16,7 +16,7 @@ import namedPlaceholders from 'named-placeholders';
 import type { PoolConnection } from 'mysql2/promise';
 import { Buffer } from 'buffer';
 import { Executor } from "./Executor";
-import {checkCache, setCache} from "../utils/cacheManager";
+import {checkCache, evictCacheEntry, setCache} from "../utils/cacheManager";
 import logSql, {
     SqlAllowListStatus,
 } from "../utils/logSql";
@@ -558,6 +558,11 @@ export class SqlExecutor<
             ? sortAndSerializeQueryObject(tableName, cacheRequestData ?? {})
             : undefined;
 
+        const evictFromCache =
+            method === C6C.GET && cacheResults && cacheRequestData
+                ? () => evictCacheEntry(method, tableName, cacheRequestData, logContext)
+                : undefined;
+
         if (cacheResults) {
             const cachedRequest = checkCache<DetermineResponseDataType<G['RequestMethod'], G['RestTableInterface']>>(
                 method,
@@ -566,7 +571,14 @@ export class SqlExecutor<
                 logContext
             );
             if (cachedRequest) {
-                return (await cachedRequest).data;
+                const cachedData = (await cachedRequest).data;
+                if (evictFromCache
+                    && cachedData
+                    && typeof cachedData === "object"
+                    && Array.isArray((cachedData as DetermineResponseDataType<'GET', G['RestTableInterface']>).rest)) {
+                    (cachedData as DetermineResponseDataType<'GET', G['RestTableInterface']>).evictFromCache = evictFromCache;
+                }
+                return cachedData;
             }
         }
 
@@ -586,9 +598,15 @@ export class SqlExecutor<
             return await queryPromise;
         }
 
-        const cacheRequest = queryPromise.then((data) =>
-            this.createCacheResponseEnvelope(method, tableName, data),
-        );
+        const cacheRequest = queryPromise.then((data) => {
+            if (evictFromCache
+                && data
+                && typeof data === "object"
+                && Array.isArray((data as DetermineResponseDataType<'GET', G['RestTableInterface']>).rest)) {
+                (data as DetermineResponseDataType<'GET', G['RestTableInterface']>).evictFromCache = evictFromCache;
+            }
+            return this.createCacheResponseEnvelope(method, tableName, data);
+        });
 
         setCache(method, tableName, cacheRequestData, {
             requestArgumentsSerialized,

package/src/types/ormInterfaces.ts

@@ -140,7 +140,10 @@ export type C6RestResponse<
     session?: any;
     sql?: any;
 } & (Method extends 'GET'
-    ? { next?: () => Promise<DetermineResponseDataType<'GET', RestData, Overrides>> }
+    ? {
+        next?: () => Promise<DetermineResponseDataType<'GET', RestData, Overrides>>,
+        evictFromCache?: () => boolean
+    }
     : {
         affected: number,
         insertId?: number | string,

package/src/utils/cacheManager.ts

@@ -67,7 +67,6 @@ export function checkCache<ResponseDataType = any>(
     const cached = apiRequestCache.get(key);
 
     if (!cached) {
-        console.log('apiRequestCache.size', apiRequestCache.size)
         return false;
     }
 
@@ -98,3 +97,28 @@ export function setCache<ResponseDataType = any>(
     const key = makeCacheKey(method, tableName, requestData);
     apiRequestCache.set(key, cacheEntry);
 }
+
+export function evictCacheEntry(
+    method: string,
+    tableName: string | string[],
+    requestData: any,
+    logContext?: LogContext,
+): boolean {
+    const key = makeCacheKey(method, tableName, requestData);
+    const cached = apiRequestCache.get(key);
+    const deleted = apiRequestCache.delete(key);
+
+    if (deleted && shouldLog(LogLevel.INFO, logContext)) {
+        const sql = cached?.response?.data?.sql?.sql ?? "";
+        const sqlMethod = sql.trim().split(/\s+/, 1)[0]?.toUpperCase() || method;
+        logSql({
+            allowListStatus: "not verified",
+            cacheStatus: "evicted",
+            context: logContext,
+            method: sqlMethod,
+            sql,
+        });
+    }
+
+    return deleted;
+}

package/src/utils/logSql.ts

@@ -6,7 +6,7 @@ import type { LogContext } from "./logLevel";
 import { LogLevel, shouldLog } from "./logLevel";
 
 export type SqlAllowListStatus = "allowed" | "denied" | "not verified";
-export type SqlCacheStatus = "hit" | "miss" | "ignored";
+export type SqlCacheStatus = "hit" | "miss" | "ignored" | "evicted";
 
 export type LogSqlContextOptions = {
     cacheStatus: SqlCacheStatus;
@@ -66,6 +66,8 @@ const cacheLabel = (cacheStatus: SqlCacheStatus): string => {
     switch (cacheStatus) {
         case "hit":
             return `${C.METHOD_COLORS.SELECT}[CACHE HIT]${C.RESET}`;
+        case "evicted":
+            return `${C.WARN}[CACHE EVICTED]${C.RESET}`;
         case "ignored":
             return `${C.WARN}[CACHE IGNORED]${C.RESET}`;
         default: