@carbonorm/carbonnode 6.0.6 → 6.0.8

package/dist/types/ormInterfaces.d.ts

@@ -171,6 +171,7 @@ export interface iRest<RestShortTableName extends string = any, RestTableInterfa
     clearCache?: () => void;
     skipPrimaryCheck?: boolean;
     websocketBroadcast?: tWebsocketBroadcast;
+    logLevel?: number;
     verbose?: boolean;
     sqlAllowListPath?: string;
 }

package/dist/utils/colorSql.d.ts

@@ -0,0 +1 @@
+export default function colorSql(sql: string): string;

package/dist/utils/logLevel.d.ts

@@ -0,0 +1,32 @@
+export declare enum LogLevel {
+    NONE = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4,
+    TRACE = 5
+}
+export type LogContext = {
+    logLevel?: number | null;
+    verbose?: boolean | null;
+    request?: {
+        debug?: boolean;
+    } | null;
+};
+export declare const parseLogLevel: (value: unknown) => LogLevel | undefined;
+export declare const getEnvLogLevel: () => LogLevel | undefined;
+export declare const resolveLogLevel: (context?: LogContext) => LogLevel;
+export declare const shouldLog: (requiredLevel: LogLevel, context?: LogContext) => boolean;
+export declare const applyLogLevelDefaults: (config: {
+    logLevel?: number | null;
+    verbose?: boolean | null;
+}, request?: {
+    debug?: boolean;
+} | null) => LogLevel;
+export declare const getLogContext: (config?: {
+    logLevel?: number | null;
+    verbose?: boolean | null;
+}, request?: {
+    debug?: boolean;
+} | null) => LogContext | undefined;
+export declare const logWithLevel: (requiredLevel: LogLevel, context: LogContext | undefined, logger: (...args: any[]) => void, ...args: any[]) => void;

package/dist/utils/logSql.d.ts

@@ -0,0 +1,2 @@
+import type { LogContext } from "./logLevel";
+export default function logSql(method: string, sql: string, context?: LogContext): void;

package/dist/utils/logger.d.ts

@@ -1,6 +1,3 @@
-/**
- * Conditionally group a log if verbose.
- */
 export declare function group(title: string, data?: any): void;
 export declare function info(message: string, ...optional: any[]): void;
 export declare function warn(message: string, ...optional: any[]): void;

package/dist/utils/versionColor.d.ts

@@ -0,0 +1,6 @@
+export interface RgbColor {
+    r: number;
+    g: number;
+    b: number;
+}
+export default function versionToRgb(version: string, step?: number): RgbColor;

package/dist/variables/getEnv.d.ts

@@ -0,0 +1,10 @@
+export declare function getEnv(key: string, fallback?: string): string;
+export declare function getEnv<T>(key: string, fallback: T): T;
+export declare function getEnvBool(key: string, fallback?: boolean): boolean;
+type EnvSource = "vite" | "runtime" | "process" | "fallback" | "missing";
+export declare function getEnvDebug<T = string>(key: string, fallback?: T): {
+    key: string;
+    value: T;
+    source: EnvSource;
+};
+export {};

package/dist/variables/isTest.d.ts

@@ -1 +1 @@
-export default function (): string | boolean;
+export default function (): boolean;

package/dist/variables/isVerbose.d.ts

@@ -1 +1 @@
-export default function (): boolean;
+export default function isVerbose(): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonorm/carbonnode",
-  "version": "6.0.6",
+  "version": "6.0.8",
   "browser": "dist/index.umd.js",
   "repository": {
     "type": "git",
@@ -8,6 +8,7 @@
   },
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.esm.js",
       "require": "./dist/index.cjs.js"
     }
@@ -54,6 +55,7 @@
     "@drop-in-gaming/barrelsby": "^0.0.2",
     "@jest/globals": "^29.7.0",
     "@rollup/plugin-commonjs": "^28",
+    "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16",
     "@rollup/plugin-typescript": "^12",
     "@types/geojson": "^7946.0.16",

package/src/__tests__/fixtures/c6.fixture.ts

@@ -1,4 +1,5 @@
 import type { iRest, C6RestfulModel } from "../../types/ormInterfaces";
+import { LogLevel } from "../../utils/logLevel";
 
 // Minimal C6 table descriptor for tests
 function tableModel<T extends Record<string, any>>(name: string, columns: Record<string, keyof T>): C6RestfulModel<string, T, keyof T & string> {
@@ -70,6 +71,7 @@ export function buildTestConfig() {
     restModel: C6.TABLES.actor,
     requestMethod: 'GET',
     verbose: false,
+    logLevel: LogLevel.DEBUG,
   } as any;
 
   return baseConfig;
@@ -97,6 +99,7 @@ export function buildBinaryTestConfig() {
     restModel: C6.TABLES.binary_test,
     requestMethod: 'POST',
     verbose: false,
+    logLevel: LogLevel.DEBUG,
   } as any;
 
   return baseConfig;
@@ -127,6 +130,7 @@ export function buildBinaryTestConfigFqn() {
     restModel: C6.TABLES.binary_test,
     requestMethod: 'POST',
     verbose: false,
+    logLevel: LogLevel.DEBUG,
   } as any;
 
   return baseConfig;
@@ -169,6 +173,7 @@ export function buildParcelConfig() {
     restModel: C6.TABLES.property_units,
     requestMethod: 'GET',
     verbose: false,
+    logLevel: LogLevel.DEBUG,
   } as any;
 
   return baseConfig;

package/src/__tests__/logLevel.test.ts

@@ -0,0 +1,54 @@
+import {afterEach, describe, expect, it} from "vitest";
+import {LogLevel, resolveLogLevel} from "../utils/logLevel";
+
+const LOG_LEVEL_KEY = "LOG_LEVEL";
+const VERBOSE_KEY = "VERBOSE";
+
+const originalLogLevel = process.env[LOG_LEVEL_KEY];
+const originalVerbose = process.env[VERBOSE_KEY];
+
+const resetEnv = () => {
+    if (originalLogLevel === undefined) {
+        delete process.env[LOG_LEVEL_KEY];
+    } else {
+        process.env[LOG_LEVEL_KEY] = originalLogLevel;
+    }
+
+    if (originalVerbose === undefined) {
+        delete process.env[VERBOSE_KEY];
+    } else {
+        process.env[VERBOSE_KEY] = originalVerbose;
+    }
+};
+
+afterEach(() => {
+    resetEnv();
+});
+
+describe("log level resolution", () => {
+    it("uses LOG_LEVEL env when set", () => {
+        process.env[LOG_LEVEL_KEY] = "1";
+        delete process.env[VERBOSE_KEY];
+
+        expect(resolveLogLevel()).toBe(LogLevel.ERROR);
+    });
+
+    it("maps VERBOSE env to DEBUG when log level env is unset", () => {
+        delete process.env[LOG_LEVEL_KEY];
+        process.env[VERBOSE_KEY] = "true";
+
+        expect(resolveLogLevel()).toBe(LogLevel.DEBUG);
+    });
+
+    it("maps verbose config to DEBUG/WARN and respects logLevel override", () => {
+        expect(resolveLogLevel({verbose: true})).toBe(LogLevel.DEBUG);
+        expect(resolveLogLevel({verbose: false})).toBe(LogLevel.WARN);
+        expect(resolveLogLevel({logLevel: LogLevel.ERROR, verbose: true})).toBe(LogLevel.ERROR);
+        expect(resolveLogLevel({logLevel: "TRACE" as any})).toBe(LogLevel.TRACE);
+    });
+
+    it("bumps request debug to DEBUG when base level is lower", () => {
+        expect(resolveLogLevel({logLevel: LogLevel.ERROR, request: {debug: true}})).toBe(LogLevel.DEBUG);
+        expect(resolveLogLevel({logLevel: LogLevel.TRACE, request: {debug: true}})).toBe(LogLevel.TRACE);
+    });
+});

package/src/__tests__/logSql.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import logSql from "../utils/logSql";
+import colorSql from "../utils/colorSql";
+import { version } from "../../package.json";
+
+const stripAnsi = (value: string) => value.replace(/\x1b\[[0-9;]*m/g, "");
+
+const SSR_ENV_KEY = "SSR";
+const originalSsr = process.env[SSR_ENV_KEY];
+const LOG_LEVEL_KEY = "LOG_LEVEL";
+const originalLogLevel = process.env[LOG_LEVEL_KEY];
+
+const restoreEnv = () => {
+    if (originalSsr === undefined) {
+        delete process.env[SSR_ENV_KEY];
+    } else {
+        process.env[SSR_ENV_KEY] = originalSsr;
+    }
+
+    if (originalLogLevel === undefined) {
+        delete process.env[LOG_LEVEL_KEY];
+    } else {
+        process.env[LOG_LEVEL_KEY] = originalLogLevel;
+    }
+};
+
+afterEach(() => {
+    restoreEnv();
+    vi.restoreAllMocks();
+});
+
+describe("logSql", () => {
+    it("logs API prefix when SSR is disabled", () => {
+        process.env[SSR_ENV_KEY] = "false";
+        process.env[LOG_LEVEL_KEY] = "DEBUG";
+        const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+        logSql("SELECT", "SELECT * FROM `users`");
+
+        expect(spy).toHaveBeenCalledTimes(1);
+        const message = stripAnsi(String(spy.mock.calls[0][0]));
+        expect(message).toContain(`[${version}]`);
+        expect(message).toContain("[API]");
+        expect(message).toContain("[SELECT]");
+        expect(message).toContain("SELECT * FROM `users`");
+    });
+
+    it("logs SSR prefix when SSR is enabled", () => {
+        process.env[SSR_ENV_KEY] = "true";
+        process.env[LOG_LEVEL_KEY] = "DEBUG";
+        const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+        logSql("DELETE", "DELETE `users` FROM `users`");
+
+        const message = stripAnsi(String(spy.mock.calls[0][0]));
+        expect(message).toContain("[SSR]");
+        expect(message).toContain("[DELETE]");
+    });
+});
+
+describe("colorSql", () => {
+    it("highlights INSERT and UPDATE keywords", () => {
+        const sql = "INSERT INTO `users` (id) VALUES (1) ON DUPLICATE KEY UPDATE id = VALUES(id)";
+        const colored = colorSql(sql);
+
+        expect(colored).toContain("\x1b[94mINSERT\x1b[0m");
+        expect(colored).toContain("\x1b[94mUPDATE\x1b[0m");
+        expect(colored).toContain("\x1b[94mDUPLICATE\x1b[0m");
+    });
+});

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

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