@carbonorm/carbonnode 6.0.18 → 6.0.20

package/dist/types/ormInterfaces.d.ts

@@ -105,6 +105,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): boolean;
+export declare function evictCacheEntry(method: string, tableName: string | string[], requestData: any, logContext?: LogContext, allowListStatus?: SqlAllowListStatus): 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.18",
+  "version": "6.0.20",
   "browser": "dist/index.umd.js",
   "repository": {
     "type": "git",

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,57 @@ 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,
+      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__/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.18',
+    C6VERSION: '6.0.20',
     IMPORT: async (tableName) => {
         tableName = tableName.toLowerCase();
         // if tableName is not a key in the TABLES object then throw an error