@carbonorm/carbonnode 6.0.13 → 6.0.17

package/dist/utils/cacheManager.d.ts

@@ -1,8 +1,9 @@
 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;

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.13",
+  "version": "6.0.17",
   "browser": "dist/index.umd.js",
   "repository": {
     "type": "git",

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.multiRowUpsert.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it, vi } from "vitest";
+import { C6C, restOrm } from "@carbonorm/carbonnode";
+import { buildTestConfig } from "./fixtures/c6.fixture";
+
+describe("HttpExecutor multi-row upsert payload", () => {
+  it("preserves UPDATE metadata when posting dataInsertMultipleRows", async () => {
+    const post = vi.fn().mockResolvedValue({
+      data: {
+        created: 1,
+        rest: {},
+      },
+    });
+
+    const baseConfig = buildTestConfig() as any;
+    const actorHttp = restOrm<any>(() => ({
+      ...baseConfig,
+      requestMethod: C6C.POST,
+      restURL: "http://127.0.0.1:9999/rest/",
+      axios: { post },
+      verbose: false,
+    }));
+
+    await actorHttp.Post({
+      dataInsertMultipleRows: [
+        {
+          "actor.actor_id": 1,
+          "actor.first_name": "ALICE",
+          "actor.last_name": "ONE",
+        },
+        {
+          "actor.actor_id": 2,
+          "actor.first_name": "BOB",
+          "actor.last_name": "TWO",
+        },
+      ],
+      [C6C.UPDATE]: ["first_name", "last_name"],
+    } as any);
+
+    expect(post).toHaveBeenCalledTimes(1);
+
+    const payload = post.mock.calls[0][1];
+    expect(payload[C6C.UPDATE]).toEqual(["first_name", "last_name"]);
+    expect(payload.dataInsertMultipleRows).toHaveLength(2);
+    expect(payload.dataInsertMultipleRows[0]).toMatchObject({
+      "actor.actor_id": 1,
+      "actor.first_name": "ALICE",
+      "actor.last_name": "ONE",
+    });
+  });
+});

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