@carbonorm/carbonnode 6.0.14 → 6.0.18

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

@@ -1,8 +1,10 @@
 import type { iCacheAPI, iCacheResponse } from "../types/ormInterfaces";
+import { LogContext } from "./logLevel";
 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): Promise<iCacheResponse<ResponseDataType>> | false;
+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): boolean;

package/dist/utils/logLevel.d.ts

@@ -23,10 +23,10 @@ export declare const applyLogLevelDefaults: (config: {
 }, request?: {
     debug?: boolean;
 } | null) => LogLevel;
-export declare const getLogContext: (config?: {
+export declare const getLogContext: (config: {
     logLevel?: number | null;
     verbose?: boolean | null;
-}, request?: {
+}, request: {
     debug?: boolean;
-} | null) => LogContext | undefined;
+} | null) => LogContext;
 export declare const logWithLevel: (requiredLevel: LogLevel, context: LogContext | undefined, logger: (...args: any[]) => void, ...args: any[]) => void;

package/dist/utils/logSql.d.ts

@@ -1,2 +1,11 @@
 import type { LogContext } from "./logLevel";
-export default function logSql(method: string, sql: string, context?: LogContext): void;
+export type SqlAllowListStatus = "allowed" | "denied" | "not verified";
+export type SqlCacheStatus = "hit" | "miss" | "ignored";
+export type LogSqlContextOptions = {
+    cacheStatus: SqlCacheStatus;
+    allowListStatus: SqlAllowListStatus;
+    method: string;
+    sql: string;
+    context?: LogContext;
+};
+export default function logSql(options: LogSqlContextOptions): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonorm/carbonnode",
-  "version": "6.0.14",
+  "version": "6.0.18",
   "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/scripts/assets/handlebars/C6.ts.handlebars

@@ -147,7 +147,7 @@ export const C6 : iC6Object<RestTableInterfaces> = {
     ...TABLES
 };
 
-export type tStatefulApiData<T> = T[] | undefined | null;
+export type tStatefulApiData<T> = T[] | undefined;
 
 // this refers to the value types of the keys above, aka values in the state
 export interface iRestfulObjectArrayTypes {

package/src/__tests__/fixtures/sqlResponses/sqlAllowList.json

@@ -1,3 +1,3 @@
 [
-  "SELECT * FROM `actor` LIMIT 1"
+  "SELECT * FROM `actor` LIMIT ?"
 ]

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

@@ -1,3 +1,5 @@
+// noinspection SqlResolve
+
 import { describe, it, expect, vi, afterEach } from "vitest";
 import logSql from "../utils/logSql";
 import colorSql from "../utils/colorSql";
@@ -35,13 +37,21 @@ describe("logSql", () => {
         process.env[LOG_LEVEL_KEY] = "DEBUG";
         const spy = vi.spyOn(console, "log").mockImplementation(() => {});
 
-        logSql("SELECT", "SELECT * FROM `users`");
+        logSql({
+            method: "SELECT",
+            sql: "SELECT * FROM `users`",
+            cacheStatus: "miss",
+            allowListStatus: "not verified",
+        });
 
         expect(spy).toHaveBeenCalledTimes(1);
         const message = stripAnsi(String(spy.mock.calls[0][0]));
         expect(message).toContain(`[${version}]`);
+        expect(message).toContain("[CACHE MISS]");
+        expect(message).toContain("[NOT VERIFIED]");
         expect(message).toContain("[API]");
         expect(message).toContain("[SELECT]");
+        // noinspection SqlResolve - resolve not intended for this test
         expect(message).toContain("SELECT * FROM `users`");
     });
 
@@ -50,12 +60,53 @@ describe("logSql", () => {
         process.env[LOG_LEVEL_KEY] = "DEBUG";
         const spy = vi.spyOn(console, "log").mockImplementation(() => {});
 
-        logSql("DELETE", "DELETE `users` FROM `users`");
+        logSql({
+            method: "DELETE",
+            sql: "DELETE `users` FROM `users`",
+            cacheStatus: "miss",
+            allowListStatus: "not verified",
+        });
 
         const message = stripAnsi(String(spy.mock.calls[0][0]));
+        expect(message).toContain("[CACHE MISS]");
+        expect(message).toContain("[NOT VERIFIED]");
         expect(message).toContain("[SSR]");
         expect(message).toContain("[DELETE]");
     });
+
+    it("supports explicit cache and allowlist indicators", () => {
+        process.env[SSR_ENV_KEY] = "false";
+        process.env[LOG_LEVEL_KEY] = "DEBUG";
+        const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+        // noinspection SqlResolve - resolve not intended for this test
+        logSql({
+            method: "SELECT",
+            sql: "SELECT * FROM `users`",
+            cacheStatus: "ignored",
+            allowListStatus: "allowed",
+        });
+
+        const message = stripAnsi(String(spy.mock.calls[0][0]));
+        expect(message).toContain("[CACHE IGNORED]");
+        expect(message).toContain("[VERIFIED]");
+    });
+
+    it("supports cache-hit 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: "hit",
+            allowListStatus: "allowed",
+        });
+
+        const message = stripAnsi(String(spy.mock.calls[0][0]));
+        expect(message).toContain("[CACHE HIT]");
+    });
 });
 
 describe("colorSql", () => {
@@ -69,6 +120,7 @@ describe("colorSql", () => {
     });
 
     it("collapses repeated multi-row value groups", () => {
+        // noinspection SqlResolve - resolve not intended for this test
         const sql = `INSERT INTO \`valuation_report_comparables\` (a,b,c) VALUES
             (?, ?, ?),
             (?, ?, ?),

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

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