@carbonorm/carbonnode 6.0.6 → 6.0.7

package/src/__tests__/sqlBuilders.test.ts

@@ -1,10 +1,11 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { C6C } from '../constants/C6Constants';
 import { SelectQueryBuilder } from '../orm/queries/SelectQueryBuilder';
 import { PostQueryBuilder } from '../orm/queries/PostQueryBuilder';
 import { UpdateQueryBuilder } from '../orm/queries/UpdateQueryBuilder';
 import { DeleteQueryBuilder } from '../orm/queries/DeleteQueryBuilder';
 import { buildTestConfig, buildBinaryTestConfig, buildBinaryTestConfigFqn } from './fixtures/c6.fixture';
+import { version } from '../../package.json';
 
 describe('SQL Builders', () => {
   it('builds SELECT with JOIN, WHERE, GROUP BY, HAVING and default LIMIT', () => {
@@ -43,6 +44,25 @@ describe('SQL Builders', () => {
     expect(params).toEqual(['%A%', 10, 1]);
   });
 
+  it('logs SELECT statements with package version', () => {
+    const config = buildTestConfig();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    const qb = new SelectQueryBuilder(config as any, {
+      SELECT: ['actor.first_name'],
+    } as any, false);
+
+    qb.build('actor');
+
+    const logLines = logSpy.mock.calls
+      .map((call) => call[0])
+      .filter((entry): entry is string => typeof entry === 'string');
+    const selectLine = logLines.find((line) => line.includes('[SELECT]'));
+
+    expect(selectLine).toBeDefined();
+    expect(selectLine).toContain(`[${version}]`);
+    logSpy.mockRestore();
+  });
+
   it('builds INSERT with ON DUPLICATE KEY UPDATE', () => {
     const config = buildTestConfig();
     const qb = new PostQueryBuilder(config as any, {

package/src/api/restRequest.ts

@@ -35,22 +35,21 @@ export default function restRequest<
 
         config.verbose ??= isVerbose(); // Default to env-driven verbosity if not set
 
+        if (!config.mysqlPool && !config.axios) {
+            throw new Error("No execution method available: neither mysqlPool nor axios instance provided in config.");
+        }
+
         // SQL path if on Node with a provided pool
-        if (isNode() && config.mysqlPool) {
-            if (config.verbose) {
-                console.log("Using SQL Executor");
-            }
+        if (config.mysqlPool) {
+            config.verbose && console.log("Using SQL Executor");
             const {SqlExecutor} = await import('../executors/SqlExecutor');
             const executor = new SqlExecutor<G>(config, request);
             return executor.execute();
         }
 
-        if (config.verbose) {
-            console.log("Using HTTP Executor", {
-                isNode: isNode(),
-                hasPool: !!config.mysqlPool
-            });
-        }
+        config.verbose && console.log("Using HTTP Executor", {
+            isNode: isNode(),
+        });
 
         // HTTP path fallback
         const {HttpExecutor} = await import('../executors/HttpExecutor');

package/src/executors/HttpExecutor.ts

@@ -844,7 +844,7 @@ export class HttpExecutor<
 
                 console.groupEnd()
 
-                throw new Error(JSON.stringify(throwableError))
+                throw throwableError
 
             }
 

package/src/index.ts

@@ -33,6 +33,8 @@ export * from "./types/ormGenerics";
 export * from "./types/ormInterfaces";
 export * from "./utils/apiHelpers";
 export * from "./utils/cacheManager";
+export { default as colorSql } from "./utils/colorSql";
+export * from "./utils/colorSql";
 export * from "./utils/determineRuntimeJsType";
 export * from "./utils/logger";
 export * from "./utils/normalizeSingularRequest";
@@ -41,7 +43,7 @@ export * from "./utils/sqlAllowList";
 export * from "./utils/testHelpers";
 export * from "./utils/toastNotifier";
 export * from "./utils/toastRuntime";
-export * from "./variables/getEnvVar";
+export * from "./variables/getEnv";
 export { default as isLocal } from "./variables/isLocal";
 export * from "./variables/isLocal";
 export { default as isNode } from "./variables/isNode";

package/src/orm/queries/SelectQueryBuilder.ts

@@ -1,6 +1,17 @@
 import {OrmGenerics} from "../../types/ormGenerics";
 import {PaginationBuilder} from "../builders/PaginationBuilder";
 import {SqlBuilderResult} from "../utils/sqlUtils";
+import {getEnvBool} from "../../variables/getEnv";
+import colorSql from "../../utils/colorSql";
+import { version } from "../../../package.json";
+
+
+const C = {
+    SSR: "\x1b[95m",     // bright magenta
+    HTTP: "\x1b[94m",    // bright blue
+    SQL: "\x1b[96m",     // bright cyan (your SELECT teal)
+    RESET: "\x1b[0m",
+};
 
 export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
 
@@ -56,7 +67,9 @@ export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
             sql += ` LIMIT 100`;
         }
 
-        console.log(`[SELECT] ${sql.trim()}`);
+        const preText = getEnvBool("SSR", false) ? `${C.SSR}[SSR]${C.RESET} ` : `${C.HTTP}[API]${C.RESET} `;
+
+        console.log(`[${version}] ${preText}${C.SQL}[SELECT]${C.RESET} ${colorSql(sql)}`);
 
         return { sql, params };
     }

package/src/utils/colorSql.ts

@@ -0,0 +1,112 @@
+/* eslint-disable no-control-regex */
+
+const RESET = "\x1b[0m";
+
+const C = {
+    KEYWORD: "\x1b[94m", // blue
+    LIMIT: "\x1b[93m",   // yellow
+    NUMBER: "\x1b[92m",  // green
+    DIM: "\x1b[90m",     // gray
+};
+
+/* ---------- ANSI helpers ---------- */
+
+const ansi256 = (n: number) => `\x1b[38;5;${n}m`;
+
+/* ---------- hashing ---------- */
+
+function hashString(str: string): number {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash * 31 + str.charCodeAt(i)) | 0;
+    }
+    return Math.abs(hash);
+}
+
+/* ---------- table color ---------- */
+
+function tableRGB(tableName: string): [number, number, number] {
+    const name = tableName.replace(/[`"]/g, "").toLowerCase();
+    const hash = hashString(name);
+
+    // Stable hue bucket by first letter
+    const first = name.charCodeAt(0) || 97;
+    const hueBase = (first - 97) % 6;
+
+    const r = (hueBase + (hash % 3)) % 6;
+    const g = (hash >> 3) % 6;
+    const b = (hash >> 6) % 6;
+
+    return [r, g, Math.max(2, b)]; // avoid muddy dark blues
+}
+
+function tableColor(table: string): string {
+    const [r, g, b] = tableRGB(table);
+    return ansi256(16 + 36 * r + 6 * g + b);
+}
+
+/* ---------- column color (same hue, lighter) ---------- */
+
+function columnColorFromTable(table: string): string {
+    const [r, g, b] = tableRGB(table);
+
+    // Lift toward white, preserve hue
+    const lr = Math.min(5, r + 1);
+    const lg = Math.min(5, g + 1);
+    const lb = Math.min(5, b + 2);
+
+    return ansi256(16 + 36 * lr + 6 * lg + lb);
+}
+
+/* ---------- bind collapsing ---------- */
+/**
+ * ?, ?, ?, ?, ?, ?  →  ? ×6
+ * triggers at 4+
+ */
+function collapseBinds(sql: string): string {
+    return sql.replace(
+        /(\?\s*,\s*){3,}\?/g,
+        (match) => {
+            const count = match.split("?").length - 1;
+            return `${C.DIM}? ×${count}${RESET}`;
+        },
+    );
+}
+
+/* ---------- main formatter ---------- */
+
+export default function colorSql(sql: string): string {
+    let s = sql.trim();
+
+    /* 1️⃣ collapse bind noise */
+    s = collapseBinds(s);
+
+    /* 2️⃣ table.column coloring (core visual grouping) */
+    s = s.replace(
+        /\b(`?\w+`?)\.(\w+)\b/g,
+        (_, table, column) =>
+            `${tableColor(table)}${table}${RESET}.` +
+            `${columnColorFromTable(table)}${column}${RESET}`,
+    );
+
+    /* 3️⃣ FROM / JOIN tables */
+    s = s.replace(
+        /\b(FROM|JOIN|UPDATE|INTO)\s+(`[^`]+`|\w+)/gi,
+        (_, kw, table) =>
+            `${C.KEYWORD}${kw}${RESET} ${tableColor(table)}${table}${RESET}`,
+    );
+
+    /* 4️⃣ SQL keywords */
+    s = s.replace(
+        /\b(SELECT|WHERE|AND|OR|ON|IN|BETWEEN|EXISTS|ORDER BY)\b/gi,
+        `${C.KEYWORD}$1${RESET}`,
+    );
+
+    /* 5️⃣ LIMIT */
+    s = s.replace(
+        /\bLIMIT\s+(\d+)/gi,
+        `${C.LIMIT}LIMIT${RESET} ${C.NUMBER}$1${RESET}`,
+    );
+
+    return s;
+}

package/src/variables/getEnv.ts

@@ -0,0 +1,71 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: working with global browser objects */
+function getRuntimeEnv(key: string): any {
+    return typeof window !== "undefined" && (window as any).__ENV__?.[key];
+}
+// Do not import anything here
+function getViteEnv(key: string): any {
+    // @ts-expect-error
+    return typeof import.meta !== "undefined" && import.meta.env?.[key];
+}
+
+export function getEnv(key: string, fallback?: string): string;
+export function getEnv<T>(key: string, fallback: T): T;
+export function getEnv<T = string>(key: string, fallback?: T): T {
+    try {
+        const viteEnv = getViteEnv(key);
+        if (viteEnv !== undefined) return viteEnv as T;
+    } catch {}
+
+    const runtimeEnv = getRuntimeEnv(key);
+    if (runtimeEnv !== undefined) return runtimeEnv as T;
+
+    if (typeof process !== "undefined" && process.env?.[key] !== undefined) {
+        return process.env[key] as T;
+    }
+
+    if (fallback !== undefined) return fallback;
+    throw new Error(`Missing environment variable: ${key}`);
+}
+
+export function getEnvBool(key: string, fallback = false): boolean {
+    const raw = getEnv(key, fallback);
+    const v = String(raw).trim().toLowerCase();
+
+    return (
+        v === "true" ||
+        v === "1" ||
+        v === "yes" ||
+        v === "y" ||
+        v === "on" ||
+        v === "enabled"
+    );
+}
+
+type EnvSource = "vite" | "runtime" | "process" | "fallback" | "missing";
+
+export function getEnvDebug<T = string>(
+    key: string,
+    fallback?: T,
+): { key: string; value: T; source: EnvSource } {
+    try {
+        const viteEnv = getViteEnv(key);
+        if (viteEnv !== undefined) {
+            return { key, value: viteEnv as T, source: "vite" };
+        }
+    } catch {}
+
+    const runtimeEnv = getRuntimeEnv(key);
+    if (runtimeEnv !== undefined) {
+        return { key, value: runtimeEnv as T, source: "runtime" };
+    }
+
+    if (typeof process !== "undefined" && process.env?.[key] !== undefined) {
+        return { key, value: process.env[key] as T, source: "process" };
+    }
+
+    if (fallback !== undefined) {
+        return { key, value: fallback, source: "fallback" };
+    }
+
+    return { key, value: undefined as any, source: "missing" };
+}

package/src/variables/isLocal.ts

@@ -1,7 +1,7 @@
-import {getEnvVar} from "./getEnvVar";
+import {getEnv} from "./getEnv";
 
 
 
 export default function () {
-    return  getEnvVar('NODE_ENV', '') === 'development';
+    return  getEnv('NODE_ENV', '') === 'development';
 };

package/src/variables/isTest.ts

@@ -1,8 +1,8 @@
-import {getEnvVar} from "./getEnvVar";
+import {getEnv, getEnvBool} from "./getEnv";
 
 
 export default function () {
-    return getEnvVar('JEST_WORKER_ID') || getEnvVar('NODE_ENV') === 'test'
-        || getEnvVar('REACT_APP_TEST') === 'true' || getEnvVar('VITE_TEST') === 'true'
-        || getEnvVar('MODE') === 'test' || getEnvVar('VITE_TEST_MODE') === 'true';
+    return getEnv('JEST_WORKER_ID', null) || getEnv('NODE_ENV', "") === 'test'
+        || getEnvBool('REACT_APP_TEST', false) || getEnvBool('VITE_TEST', false)
+        || getEnv('MODE', '') === 'test' || getEnvBool('VITE_TEST_MODE', false);
 };

package/src/variables/isVerbose.ts

@@ -1,6 +1,5 @@
-import {getEnvVar} from "./getEnvVar";
+import {getEnvBool} from "./getEnv";
 
 export default function () {
-    const envVerbose = getEnvVar('VERBOSE') || getEnvVar('REACT_APP_VERBOSE') || getEnvVar('VITE_VERBOSE') || ''
-    return ['true', '1', 'yes', 'on'].includes(envVerbose.toLowerCase());
+    return getEnvBool('VERBOSE', false) || getEnvBool('REACT_APP_VERBOSE', false) || getEnvBool('VITE_VERBOSE', false)
 }

package/dist/variables/getEnvVar.d.ts

@@ -1 +0,0 @@
-export declare function getEnvVar(key: string, fallback?: string): string;

package/src/variables/getEnvVar.ts

@@ -1,15 +0,0 @@
-export function getEnvVar(key: string, fallback = ''): string {
-    // Vite-style injection
-    // @ts-ignore
-    if (typeof import.meta !== 'undefined' && import.meta.env && key in import.meta.env) {
-        // @ts-ignore
-        return import.meta.env[key];
-    }
-
-    // Node or SSR
-    if (typeof process !== 'undefined' && process.env && key in process.env) {
-        return process.env[key]!;
-    }
-
-    return fallback;
-}