@carbonorm/carbonnode 6.0.17 → 6.0.19

package/dist/types/ormInterfaces.d.ts

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

package/dist/utils/cacheManager.d.ts

@@ -7,3 +7,4 @@ export declare function clearCache(props?: {
 }): void;
 export declare function checkCache<ResponseDataType = any>(method: string, tableName: string | string[], requestData: any, logContext: LogContext): 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;

package/dist/utils/logSql.d.ts

@@ -1,6 +1,6 @@
 import type { LogContext } 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;
     allowListStatus: SqlAllowListStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonorm/carbonnode",
-  "version": "6.0.17",
+  "version": "6.0.19",
   "browser": "dist/index.umd.js",
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
     "geojson": "^0.5.0",
     "handlebars": "^4.7.8",
     "named-placeholders": "^1.1.3",
-    "qs": "^6.11.1",
+    "qs": "6.14.1",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {

package/src/__tests__/cacheManager.test.ts

@@ -1,9 +1,10 @@
 import type { AxiosPromise } from "axios";
-import { describe, it, expect, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import {
   apiRequestCache,
   checkCache,
   clearCache,
+  evictCacheEntry,
   setCache,
 } from "../utils/cacheManager";
 import { checkAllRequestsComplete } from "../utils/testHelpers";
@@ -63,4 +64,29 @@ describe("cacheManager with map storage", () => {
 
     (global as any).document = originalDocument;
   });
+
+  it("logs SQL details when evicting a cached entry", () => {
+    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,
+    });
+
+    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("[SELECT]");
+
+    logSpy.mockRestore();
+  });
 });

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

@@ -0,0 +1,70 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { C6C, restOrm, apiRequestCache, clearCache } from "@carbonorm/carbonnode";
+import { buildTestConfig } from "./fixtures/c6.fixture";
+
+describe("HttpExecutor cache eviction", () => {
+  const makeResponsePayload = () => ({
+    rest: [
+      {
+        actor_id: 1,
+        first_name: "ALICE",
+        last_name: "ONE",
+      },
+    ],
+  });
+
+  const buildOrm = (get: ReturnType<typeof vi.fn>) => {
+    const baseConfig = buildTestConfig() as any;
+
+    return restOrm<any>(() => ({
+      ...baseConfig,
+      requestMethod: C6C.GET,
+      restURL: "http://127.0.0.1:9999/rest/",
+      axios: { get },
+      verbose: false,
+    }));
+  };
+
+  beforeEach(() => {
+    clearCache({ ignoreWarning: true });
+  });
+
+  it("adds evictFromCache for cached GET responses", async () => {
+    const get = vi.fn().mockResolvedValue({ data: makeResponsePayload() });
+    const actorHttp = buildOrm(get);
+
+    const response = await actorHttp.Get({ actor_id: 1, cacheResults: true } as any);
+
+    expect(get).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 get = vi.fn().mockResolvedValue({ data: makeResponsePayload() });
+    const actorHttp = buildOrm(get);
+
+    const response = await actorHttp.Get({ actor_id: 1, cacheResults: false } as any);
+
+    expect(get).toHaveBeenCalledTimes(1);
+    expect(response.evictFromCache).toBeUndefined();
+    expect(apiRequestCache.size).toBe(0);
+  });
+
+  it("keeps evictFromCache on cache hits", async () => {
+    const get = vi.fn().mockResolvedValue({ data: makeResponsePayload() });
+    const actorHttp = buildOrm(get);
+
+    await actorHttp.Get({ actor_id: 1, cacheResults: true } as any);
+    const cached = await actorHttp.Get({ actor_id: 1, cacheResults: true } as any);
+
+    expect(get).toHaveBeenCalledTimes(1);
+    expect(typeof cached.evictFromCache).toBe("function");
+    expect(cached.evictFromCache?.()).toBe(true);
+    expect(apiRequestCache.size).toBe(0);
+  });
+});

package/src/__tests__/logSql.test.ts

@@ -107,6 +107,22 @@ describe("logSql", () => {
         const message = stripAnsi(String(spy.mock.calls[0][0]));
         expect(message).toContain("[CACHE HIT]");
     });
+
+    it("supports cache-evicted indicators", () => {
+        process.env[SSR_ENV_KEY] = "false";
+        process.env[LOG_LEVEL_KEY] = "DEBUG";
+        const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+        logSql({
+            method: "SELECT",
+            sql: "SELECT * FROM `users`",
+            cacheStatus: "evicted",
+            allowListStatus: "allowed",
+        });
+
+        const message = stripAnsi(String(spy.mock.calls[0][0]));
+        expect(message).toContain("[CACHE EVICTED]");
+    });
 });
 
 describe("colorSql", () => {

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

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